2016-05-04 19:24:41 +02:00
|
|
|
#pragma region Copyright (c) 2014-2016 OpenRCT2 Developers
|
2015-02-12 03:01:02 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* OpenRCT2, an open source clone of Roller Coaster Tycoon 2.
|
|
|
|
*
|
2016-05-04 19:24:41 +02:00
|
|
|
* OpenRCT2 is the work of many authors, a full list can be found in contributors.md
|
|
|
|
* For more information, visit https://github.com/OpenRCT2/OpenRCT2
|
2015-02-12 03:01:02 +01:00
|
|
|
*
|
|
|
|
* OpenRCT2 is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
2016-05-04 19:24:41 +02:00
|
|
|
*
|
|
|
|
* A full copy of the GNU General Public License can be found in licence.txt
|
2015-02-12 03:01:02 +01:00
|
|
|
*****************************************************************************/
|
2016-05-04 19:24:41 +02:00
|
|
|
#pragma endregion
|
2015-02-12 03:01:02 +01:00
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
#include <SDL_platform.h>
|
|
|
|
|
|
|
|
#ifdef __WINDOWS__
|
|
|
|
// winsock2 must be included before windows.h
|
|
|
|
#include <winsock2.h>
|
|
|
|
#else
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#endif
|
|
|
|
|
2015-08-04 01:08:42 +02:00
|
|
|
extern "C" {
|
2015-11-09 00:50:38 +01:00
|
|
|
#include "../openrct2.h"
|
2015-08-04 01:08:42 +02:00
|
|
|
#include "../platform/platform.h"
|
|
|
|
}
|
2015-08-29 03:04:54 +02:00
|
|
|
|
2015-08-18 09:30:55 +02:00
|
|
|
#include "network.h"
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
#include "../addresses.h"
|
|
|
|
}
|
|
|
|
|
2015-02-12 03:01:02 +01:00
|
|
|
#ifndef DISABLE_NETWORK
|
|
|
|
|
2015-10-03 18:48:16 +02:00
|
|
|
#include <cmath>
|
|
|
|
#include <cerrno>
|
2015-07-16 19:32:43 +02:00
|
|
|
#include <algorithm>
|
2015-07-09 04:19:12 +02:00
|
|
|
#include <set>
|
2015-10-27 04:43:33 +01:00
|
|
|
#include <string>
|
2016-05-25 21:26:12 +02:00
|
|
|
|
|
|
|
#include "../core/Console.hpp"
|
2016-05-21 00:16:28 +02:00
|
|
|
#include "../core/Json.hpp"
|
2016-05-25 21:46:59 +02:00
|
|
|
#include "../core/Path.hpp"
|
|
|
|
#include "../core/String.hpp"
|
2016-05-25 21:26:12 +02:00
|
|
|
#include "../core/Util.hpp"
|
|
|
|
|
2015-07-07 16:09:21 +02:00
|
|
|
extern "C" {
|
2015-08-16 17:36:57 +02:00
|
|
|
#include "../config.h"
|
2015-02-12 12:30:57 +01:00
|
|
|
#include "../game.h"
|
2015-07-19 01:57:42 +02:00
|
|
|
#include "../interface/chat.h"
|
2015-07-23 00:55:43 +02:00
|
|
|
#include "../interface/window.h"
|
2016-02-26 10:22:14 +01:00
|
|
|
#include "../interface/keyboard_shortcut.h"
|
2015-02-12 17:23:49 +01:00
|
|
|
#include "../localisation/date.h"
|
|
|
|
#include "../localisation/localisation.h"
|
2016-04-23 02:58:54 +02:00
|
|
|
#include "../management/finance.h"
|
2015-11-04 00:31:09 +01:00
|
|
|
#include "../network/http.h"
|
2015-07-05 17:19:01 +02:00
|
|
|
#include "../scenario.h"
|
2015-10-27 04:43:33 +01:00
|
|
|
#include "../windows/error.h"
|
2015-10-30 15:18:29 +01:00
|
|
|
#include "../util/util.h"
|
2016-01-25 15:29:31 +01:00
|
|
|
#include "../cheats.h"
|
2016-05-19 10:23:42 +02:00
|
|
|
|
2016-05-28 19:29:56 +02:00
|
|
|
#include "NetworkAction.h"
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
#include <openssl/evp.h> // just for OpenSSL_add_all_algorithms()
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
2015-02-12 03:01:02 +01:00
|
|
|
|
|
|
|
#pragma comment(lib, "Ws2_32.lib")
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
Network gNetwork;
|
2015-07-09 04:19:12 +02:00
|
|
|
|
2015-11-08 03:12:12 +01:00
|
|
|
enum {
|
|
|
|
ADVERTISE_STATUS_DISABLED,
|
|
|
|
ADVERTISE_STATUS_UNREGISTERED,
|
|
|
|
ADVERTISE_STATUS_REGISTERED
|
|
|
|
};
|
|
|
|
|
|
|
|
enum {
|
|
|
|
MASTER_SERVER_STATUS_OK = 200,
|
|
|
|
MASTER_SERVER_STATUS_INVALID_TOKEN = 401,
|
|
|
|
MASTER_SERVER_STATUS_SERVER_NOT_FOUND = 404,
|
|
|
|
MASTER_SERVER_STATUS_INTERNAL_ERROR = 500
|
|
|
|
};
|
|
|
|
|
2016-02-27 14:12:04 +01:00
|
|
|
enum {
|
|
|
|
SERVER_EVENT_PLAYER_JOINED,
|
|
|
|
SERVER_EVENT_PLAYER_DISCONNECTED,
|
|
|
|
};
|
|
|
|
|
2015-11-08 03:22:49 +01:00
|
|
|
constexpr int MASTER_SERVER_REGISTER_TIME = 120 * 1000; // 2 minutes
|
|
|
|
constexpr int MASTER_SERVER_HEARTBEAT_TIME = 60 * 1000; // 1 minute
|
2015-11-08 03:12:12 +01:00
|
|
|
|
2016-02-26 10:22:14 +01:00
|
|
|
void network_chat_show_connected_message();
|
2016-08-15 19:08:23 +02:00
|
|
|
void network_chat_show_server_greeting();
|
2016-05-25 21:46:59 +02:00
|
|
|
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);
|
2016-05-25 22:03:18 +02:00
|
|
|
static void network_get_keymap_path(utf8 *buffer, size_t bufferSize);
|
2016-02-26 10:22:14 +01:00
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
Network::Network()
|
2015-02-12 03:01:02 +01:00
|
|
|
{
|
2015-07-10 21:53:41 +02:00
|
|
|
wsa_initialized = false;
|
|
|
|
mode = NETWORK_MODE_NONE;
|
2015-10-27 04:43:33 +01:00
|
|
|
status = NETWORK_STATUS_NONE;
|
2015-07-10 21:53:41 +02:00
|
|
|
last_tick_sent_time = 0;
|
2015-07-17 02:24:39 +02:00
|
|
|
last_ping_sent_time = 0;
|
2015-11-04 00:31:09 +01:00
|
|
|
last_advertise_time = 0;
|
2015-07-15 08:23:04 +02:00
|
|
|
client_command_handlers.resize(NETWORK_COMMAND_MAX, 0);
|
|
|
|
client_command_handlers[NETWORK_COMMAND_AUTH] = &Network::Client_Handle_AUTH;
|
|
|
|
client_command_handlers[NETWORK_COMMAND_MAP] = &Network::Client_Handle_MAP;
|
|
|
|
client_command_handlers[NETWORK_COMMAND_CHAT] = &Network::Client_Handle_CHAT;
|
|
|
|
client_command_handlers[NETWORK_COMMAND_GAMECMD] = &Network::Client_Handle_GAMECMD;
|
|
|
|
client_command_handlers[NETWORK_COMMAND_TICK] = &Network::Client_Handle_TICK;
|
2015-07-16 19:32:43 +02:00
|
|
|
client_command_handlers[NETWORK_COMMAND_PLAYERLIST] = &Network::Client_Handle_PLAYERLIST;
|
2015-07-17 02:24:39 +02:00
|
|
|
client_command_handlers[NETWORK_COMMAND_PING] = &Network::Client_Handle_PING;
|
|
|
|
client_command_handlers[NETWORK_COMMAND_PINGLIST] = &Network::Client_Handle_PINGLIST;
|
2015-11-01 08:50:44 +01:00
|
|
|
client_command_handlers[NETWORK_COMMAND_SETDISCONNECTMSG] = &Network::Client_Handle_SETDISCONNECTMSG;
|
2016-01-20 23:45:09 +01:00
|
|
|
client_command_handlers[NETWORK_COMMAND_SHOWERROR] = &Network::Client_Handle_SHOWERROR;
|
2016-01-22 07:32:40 +01:00
|
|
|
client_command_handlers[NETWORK_COMMAND_GROUPLIST] = &Network::Client_Handle_GROUPLIST;
|
2016-02-27 14:12:04 +01:00
|
|
|
client_command_handlers[NETWORK_COMMAND_EVENT] = &Network::Client_Handle_EVENT;
|
2016-05-30 23:25:43 +02:00
|
|
|
client_command_handlers[NETWORK_COMMAND_GAMEINFO] = &Network::Client_Handle_GAMEINFO;
|
2016-05-19 10:23:42 +02:00
|
|
|
client_command_handlers[NETWORK_COMMAND_TOKEN] = &Network::Client_Handle_TOKEN;
|
2015-07-15 08:23:04 +02:00
|
|
|
server_command_handlers.resize(NETWORK_COMMAND_MAX, 0);
|
|
|
|
server_command_handlers[NETWORK_COMMAND_AUTH] = &Network::Server_Handle_AUTH;
|
|
|
|
server_command_handlers[NETWORK_COMMAND_CHAT] = &Network::Server_Handle_CHAT;
|
|
|
|
server_command_handlers[NETWORK_COMMAND_GAMECMD] = &Network::Server_Handle_GAMECMD;
|
2015-07-17 02:24:39 +02:00
|
|
|
server_command_handlers[NETWORK_COMMAND_PING] = &Network::Server_Handle_PING;
|
2015-11-04 00:31:09 +01:00
|
|
|
server_command_handlers[NETWORK_COMMAND_GAMEINFO] = &Network::Server_Handle_GAMEINFO;
|
2016-05-19 10:23:42 +02:00
|
|
|
server_command_handlers[NETWORK_COMMAND_TOKEN] = &Network::Server_Handle_TOKEN;
|
|
|
|
OpenSSL_add_all_algorithms();
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Network::~Network()
|
|
|
|
{
|
|
|
|
Close();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Network::Init()
|
|
|
|
{
|
2016-01-13 23:37:13 +01:00
|
|
|
#ifdef __WINDOWS__
|
2015-07-10 21:53:41 +02:00
|
|
|
if (!wsa_initialized) {
|
2015-02-12 03:01:02 +01:00
|
|
|
log_verbose("Initialising WSA");
|
2015-07-10 21:53:41 +02:00
|
|
|
WSADATA wsa_data;
|
|
|
|
if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
|
2015-02-12 03:01:02 +01:00
|
|
|
log_error("Unable to initialise winsock.");
|
2015-07-10 21:53:41 +02:00
|
|
|
return false;
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
wsa_initialized = true;
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
2015-09-24 19:39:15 +02:00
|
|
|
#endif
|
2016-01-20 23:45:09 +01:00
|
|
|
|
2015-11-12 10:55:47 +01:00
|
|
|
status = NETWORK_STATUS_READY;
|
2016-05-30 23:25:43 +02:00
|
|
|
|
|
|
|
ServerName = std::string();
|
|
|
|
ServerDescription = std::string();
|
2016-08-14 06:15:45 +02:00
|
|
|
ServerGreeting = std::string();
|
2016-05-30 23:25:43 +02:00
|
|
|
ServerProviderName = std::string();
|
|
|
|
ServerProviderEmail = std::string();
|
|
|
|
ServerProviderWebsite = std::string();
|
2015-07-10 21:53:41 +02:00
|
|
|
return true;
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
void Network::Close()
|
2015-02-12 03:01:02 +01:00
|
|
|
{
|
2015-11-12 10:55:47 +01:00
|
|
|
if (status == NETWORK_STATUS_NONE)
|
|
|
|
{
|
|
|
|
// Already closed. This prevents a call in ~Network() to gfx_invalidate_screen()
|
|
|
|
// which may no longer be valid on Linux and would cause a segfault.
|
|
|
|
return;
|
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
if (mode == NETWORK_MODE_CLIENT) {
|
2016-06-01 23:58:21 +02:00
|
|
|
delete server_connection.Socket;
|
|
|
|
server_connection.Socket = nullptr;
|
|
|
|
} else if (mode == NETWORK_MODE_SERVER) {
|
|
|
|
delete listening_socket;
|
|
|
|
listening_socket = nullptr;
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
mode = NETWORK_MODE_NONE;
|
2015-10-27 04:43:33 +01:00
|
|
|
status = NETWORK_STATUS_NONE;
|
2016-06-01 23:58:21 +02:00
|
|
|
_lastConnectStatus = SOCKET_STATUS_CLOSED;
|
2016-05-28 20:03:57 +02:00
|
|
|
server_connection.AuthStatus = NETWORK_AUTH_NONE;
|
|
|
|
server_connection.InboundPacket.Clear();
|
|
|
|
server_connection.SetLastDisconnectReason(nullptr);
|
2015-07-16 19:32:43 +02:00
|
|
|
|
|
|
|
client_connection_list.clear();
|
|
|
|
game_command_queue.clear();
|
|
|
|
player_list.clear();
|
2016-01-20 23:45:09 +01:00
|
|
|
group_list.clear();
|
2015-07-16 19:32:43 +02:00
|
|
|
|
2016-01-13 23:37:13 +01:00
|
|
|
#ifdef __WINDOWS__
|
2015-07-10 21:53:41 +02:00
|
|
|
if (wsa_initialized) {
|
|
|
|
WSACleanup();
|
|
|
|
wsa_initialized = false;
|
|
|
|
}
|
2015-09-24 19:39:15 +02:00
|
|
|
#endif
|
2015-09-05 19:46:13 +02:00
|
|
|
|
2016-05-30 15:24:06 +02:00
|
|
|
CloseChatLog();
|
2015-09-05 19:46:13 +02:00
|
|
|
gfx_invalidate_screen();
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
bool Network::BeginClient(const char* host, unsigned short port)
|
2015-02-12 12:30:57 +01:00
|
|
|
{
|
2015-11-04 00:31:09 +01:00
|
|
|
if (GetMode() != NETWORK_MODE_NONE) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
Close();
|
2015-07-10 21:53:41 +02:00
|
|
|
if (!Init())
|
|
|
|
return false;
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2016-06-02 19:50:37 +02:00
|
|
|
mode = NETWORK_MODE_CLIENT;
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
assert(server_connection.Socket == nullptr);
|
|
|
|
server_connection.Socket = CreateTcpSocket();
|
|
|
|
server_connection.Socket->ConnectAsync(host, port);
|
|
|
|
status = NETWORK_STATUS_CONNECTING;
|
|
|
|
_lastConnectStatus = SOCKET_STATUS_CLOSED;
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2016-05-30 15:24:06 +02:00
|
|
|
BeginChatLog();
|
|
|
|
|
2016-05-25 21:46:59 +02:00
|
|
|
utf8 keyPath[MAX_PATH];
|
|
|
|
network_get_private_key_path(keyPath, sizeof(keyPath), gConfigNetwork.player_name);
|
2016-05-19 10:23:42 +02:00
|
|
|
if (!platform_file_exists(keyPath)) {
|
2016-05-25 21:26:12 +02:00
|
|
|
Console::WriteLine("Generating key... This may take a while");
|
|
|
|
Console::WriteLine("Need to collect enough entropy from the system");
|
2016-05-19 10:23:42 +02:00
|
|
|
key.Generate();
|
2016-05-25 21:26:12 +02:00
|
|
|
Console::WriteLine("Key generated, saving private bits as %s", keyPath);
|
2016-05-25 21:46:59 +02:00
|
|
|
|
|
|
|
utf8 keysDirectory[MAX_PATH];
|
|
|
|
network_get_keys_directory(keysDirectory, sizeof(keysDirectory));
|
|
|
|
if (!platform_ensure_directory_exists(keysDirectory)) {
|
|
|
|
log_error("Unable to create directory %s.", keysDirectory);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
SDL_RWops *privkey = SDL_RWFromFile(keyPath, "wb+");
|
2016-05-25 21:46:59 +02:00
|
|
|
if (privkey == nullptr) {
|
|
|
|
log_error("Unable to save private key at %s.", keyPath);
|
|
|
|
return false;
|
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
key.SavePrivate(privkey);
|
|
|
|
SDL_RWclose(privkey);
|
|
|
|
|
2016-05-27 23:32:11 +02:00
|
|
|
const std::string hash = key.PublicKeyHash();
|
|
|
|
const utf8 *publicKeyHash = hash.c_str();
|
2016-05-25 21:46:59 +02:00
|
|
|
network_get_public_key_path(keyPath, sizeof(keyPath), gConfigNetwork.player_name, publicKeyHash);
|
2016-05-25 21:26:12 +02:00
|
|
|
Console::WriteLine("Key generated, saving public bits as %s", keyPath);
|
2016-05-19 10:23:42 +02:00
|
|
|
SDL_RWops *pubkey = SDL_RWFromFile(keyPath, "wb+");
|
2016-05-25 21:46:59 +02:00
|
|
|
if (pubkey == nullptr) {
|
|
|
|
log_error("Unable to save public key at %s.", keyPath);
|
|
|
|
return false;
|
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
key.SavePublic(pubkey);
|
|
|
|
SDL_RWclose(pubkey);
|
|
|
|
} else {
|
|
|
|
log_verbose("Loading key from %s", keyPath);
|
|
|
|
SDL_RWops *privkey = SDL_RWFromFile(keyPath, "rb");
|
2016-05-25 21:46:59 +02:00
|
|
|
if (privkey == nullptr) {
|
|
|
|
log_error("Unable to read private key from %s.", keyPath);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
// LoadPrivate returns validity of loaded key
|
|
|
|
bool ok = key.LoadPrivate(privkey);
|
|
|
|
SDL_RWclose(privkey);
|
|
|
|
// Don't store private key in memory when it's not in use.
|
|
|
|
key.Unload();
|
|
|
|
return ok;
|
|
|
|
}
|
2015-07-15 08:23:04 +02:00
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
return true;
|
2015-02-12 12:30:57 +01:00
|
|
|
}
|
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
bool Network::BeginServer(unsigned short port, const char* address)
|
2015-02-12 12:30:57 +01:00
|
|
|
{
|
2015-07-16 19:32:43 +02:00
|
|
|
Close();
|
2015-07-10 21:53:41 +02:00
|
|
|
if (!Init())
|
|
|
|
return false;
|
2015-02-12 03:01:02 +01:00
|
|
|
|
2016-06-02 19:50:37 +02:00
|
|
|
mode = NETWORK_MODE_SERVER;
|
|
|
|
|
2016-05-27 00:52:40 +02:00
|
|
|
_userManager.Load();
|
2016-05-28 17:45:09 +02:00
|
|
|
|
2015-02-12 03:01:02 +01:00
|
|
|
log_verbose("Begin listening for clients");
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
assert(listening_socket == nullptr);
|
|
|
|
listening_socket = CreateTcpSocket();
|
2016-06-02 19:50:37 +02:00
|
|
|
try
|
|
|
|
{
|
|
|
|
listening_socket->Listen(address, port);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
Console::Error::WriteLine(ex.GetMsg());
|
|
|
|
Close();
|
|
|
|
return false;
|
|
|
|
}
|
2015-07-07 16:09:21 +02:00
|
|
|
|
2016-07-19 22:53:18 +02:00
|
|
|
ServerName = String::ToStd(gConfigNetwork.server_name);
|
|
|
|
ServerDescription = String::ToStd(gConfigNetwork.server_description);
|
2016-08-14 06:15:45 +02:00
|
|
|
ServerGreeting = String::ToStd(gConfigNetwork.server_greeting);
|
2016-07-19 22:53:18 +02:00
|
|
|
ServerProviderName = String::ToStd(gConfigNetwork.provider_name);
|
|
|
|
ServerProviderEmail = String::ToStd(gConfigNetwork.provider_email);
|
|
|
|
ServerProviderWebsite = String::ToStd(gConfigNetwork.provider_website);
|
2016-05-30 23:25:43 +02:00
|
|
|
|
2016-01-25 15:29:31 +01:00
|
|
|
cheats_reset();
|
2016-01-24 02:05:53 +01:00
|
|
|
LoadGroups();
|
2016-05-30 15:24:06 +02:00
|
|
|
BeginChatLog();
|
2016-01-24 02:05:53 +01:00
|
|
|
|
2016-05-25 23:01:10 +02:00
|
|
|
NetworkPlayer *player = AddPlayer(gConfigNetwork.player_name, "");
|
2015-07-16 19:32:43 +02:00
|
|
|
player->flags |= NETWORK_PLAYER_FLAG_ISSERVER;
|
2016-01-22 04:32:51 +01:00
|
|
|
player->group = 0;
|
2015-07-24 01:22:03 +02:00
|
|
|
player_id = player->id;
|
2015-07-16 19:32:43 +02:00
|
|
|
|
2015-07-08 03:21:05 +02:00
|
|
|
printf("Ready for clients...\n");
|
2016-02-26 10:22:14 +01:00
|
|
|
network_chat_show_connected_message();
|
2016-08-15 19:08:23 +02:00
|
|
|
network_chat_show_server_greeting();
|
2015-07-07 16:09:21 +02:00
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
status = NETWORK_STATUS_CONNECTED;
|
|
|
|
listening_port = port;
|
2015-11-08 03:12:12 +01:00
|
|
|
advertise_status = ADVERTISE_STATUS_DISABLED;
|
|
|
|
last_advertise_time = 0;
|
|
|
|
last_heartbeat_time = 0;
|
|
|
|
advertise_token = "";
|
|
|
|
advertise_key = GenerateAdvertiseKey();
|
2015-11-04 00:31:09 +01:00
|
|
|
|
2015-11-08 03:12:12 +01:00
|
|
|
#ifndef DISABLE_HTTP
|
|
|
|
if (gConfigNetwork.advertise) {
|
|
|
|
advertise_status = ADVERTISE_STATUS_UNREGISTERED;
|
|
|
|
}
|
|
|
|
#endif
|
2016-05-30 15:24:06 +02:00
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
return true;
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
int Network::GetMode()
|
2015-02-12 03:01:02 +01:00
|
|
|
{
|
2015-07-10 21:53:41 +02:00
|
|
|
return mode;
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
int Network::GetStatus()
|
|
|
|
{
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
int Network::GetAuthStatus()
|
|
|
|
{
|
|
|
|
if (GetMode() == NETWORK_MODE_CLIENT) {
|
2016-05-28 20:03:57 +02:00
|
|
|
return server_connection.AuthStatus;
|
2015-07-16 19:32:43 +02:00
|
|
|
} else
|
|
|
|
if (GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
return NETWORK_AUTH_OK;
|
|
|
|
}
|
|
|
|
return NETWORK_AUTH_NONE;
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
uint32 Network::GetServerTick()
|
2015-02-12 12:30:57 +01:00
|
|
|
{
|
2015-07-10 21:53:41 +02:00
|
|
|
return server_tick;
|
2015-07-08 03:21:05 +02:00
|
|
|
}
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2015-07-24 01:22:03 +02:00
|
|
|
uint8 Network::GetPlayerID()
|
|
|
|
{
|
|
|
|
return player_id;
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
void Network::Update()
|
2015-07-08 03:21:05 +02:00
|
|
|
{
|
2015-08-16 00:19:15 +02:00
|
|
|
switch (GetMode()) {
|
|
|
|
case NETWORK_MODE_SERVER:
|
|
|
|
UpdateServer();
|
|
|
|
break;
|
|
|
|
case NETWORK_MODE_CLIENT:
|
|
|
|
UpdateClient();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::UpdateServer()
|
|
|
|
{
|
|
|
|
auto it = client_connection_list.begin();
|
|
|
|
while (it != client_connection_list.end()) {
|
|
|
|
if (!ProcessConnection(*(*it))) {
|
|
|
|
RemoveClient((*it));
|
|
|
|
it = client_connection_list.begin();
|
2015-07-10 21:53:41 +02:00
|
|
|
} else {
|
2015-08-16 00:19:15 +02:00
|
|
|
it++;
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
2015-08-16 00:19:15 +02:00
|
|
|
}
|
2015-10-27 04:43:33 +01:00
|
|
|
if (SDL_TICKS_PASSED(SDL_GetTicks(), last_tick_sent_time + 25)) {
|
2015-08-16 00:19:15 +02:00
|
|
|
Server_Send_TICK();
|
|
|
|
}
|
2015-10-27 04:43:33 +01:00
|
|
|
if (SDL_TICKS_PASSED(SDL_GetTicks(), last_ping_sent_time + 3000)) {
|
2015-08-16 00:19:15 +02:00
|
|
|
Server_Send_PING();
|
|
|
|
Server_Send_PINGLIST();
|
|
|
|
}
|
2015-11-08 03:12:12 +01:00
|
|
|
|
|
|
|
switch (advertise_status) {
|
|
|
|
case ADVERTISE_STATUS_UNREGISTERED:
|
2015-11-08 04:55:30 +01:00
|
|
|
if (last_advertise_time == 0 || SDL_TICKS_PASSED(SDL_GetTicks(), last_advertise_time + MASTER_SERVER_REGISTER_TIME)) {
|
2015-11-08 03:12:12 +01:00
|
|
|
AdvertiseRegister();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ADVERTISE_STATUS_REGISTERED:
|
|
|
|
if (SDL_TICKS_PASSED(SDL_GetTicks(), last_heartbeat_time + MASTER_SERVER_HEARTBEAT_TIME)) {
|
|
|
|
AdvertiseHeartbeat();
|
|
|
|
}
|
|
|
|
break;
|
2015-11-04 00:31:09 +01:00
|
|
|
}
|
2015-11-08 03:12:12 +01:00
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
ITcpSocket * tcpSocket = listening_socket->Accept();
|
|
|
|
if (tcpSocket != nullptr) {
|
|
|
|
AddClient(tcpSocket);
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
2015-08-16 00:19:15 +02:00
|
|
|
}
|
2015-08-14 17:59:27 +02:00
|
|
|
|
2015-08-16 00:19:15 +02:00
|
|
|
void Network::UpdateClient()
|
|
|
|
{
|
2015-10-27 04:43:33 +01:00
|
|
|
switch(status){
|
2016-06-01 23:58:21 +02:00
|
|
|
case NETWORK_STATUS_CONNECTING:
|
|
|
|
{
|
|
|
|
switch (server_connection.Socket->GetStatus()) {
|
|
|
|
case SOCKET_STATUS_RESOLVING:
|
|
|
|
{
|
|
|
|
if (_lastConnectStatus != SOCKET_STATUS_RESOLVING)
|
|
|
|
{
|
|
|
|
_lastConnectStatus = SOCKET_STATUS_RESOLVING;
|
|
|
|
char str_resolving[256];
|
|
|
|
format_string(str_resolving, STR_MULTIPLAYER_RESOLVING, NULL);
|
|
|
|
window_network_status_open(str_resolving, []() -> void {
|
|
|
|
gNetwork.Close();
|
|
|
|
});
|
2015-10-27 04:43:33 +01:00
|
|
|
}
|
2016-06-01 23:58:21 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SOCKET_STATUS_CONNECTING:
|
|
|
|
{
|
|
|
|
if (_lastConnectStatus != SOCKET_STATUS_CONNECTING)
|
|
|
|
{
|
|
|
|
_lastConnectStatus = SOCKET_STATUS_CONNECTING;
|
2016-02-18 14:52:02 +01:00
|
|
|
char str_connecting[256];
|
2016-02-18 17:43:47 +01:00
|
|
|
format_string(str_connecting, STR_MULTIPLAYER_CONNECTING, NULL);
|
2016-03-23 00:27:49 +01:00
|
|
|
window_network_status_open(str_connecting, []() -> void {
|
|
|
|
gNetwork.Close();
|
|
|
|
});
|
2015-10-27 04:43:33 +01:00
|
|
|
server_connect_time = SDL_GetTicks();
|
|
|
|
}
|
2015-10-29 21:41:49 +01:00
|
|
|
break;
|
|
|
|
}
|
2016-06-01 23:58:21 +02:00
|
|
|
case NETWORK_STATUS_CONNECTED:
|
|
|
|
{
|
|
|
|
status = NETWORK_STATUS_CONNECTED;
|
|
|
|
server_connection.ResetLastPacketTime();
|
|
|
|
Client_Send_TOKEN();
|
|
|
|
char str_authenticating[256];
|
|
|
|
format_string(str_authenticating, STR_MULTIPLAYER_AUTHENTICATING, NULL);
|
|
|
|
window_network_status_open(str_authenticating, []() -> void {
|
|
|
|
gNetwork.Close();
|
|
|
|
});
|
2015-10-27 04:43:33 +01:00
|
|
|
break;
|
|
|
|
}
|
2016-06-01 23:58:21 +02:00
|
|
|
default:
|
|
|
|
{
|
|
|
|
const char * error = server_connection.Socket->GetError();
|
|
|
|
if (error != nullptr) {
|
|
|
|
Console::Error::WriteLine(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
Close();
|
|
|
|
window_network_status_close();
|
|
|
|
window_error_open(STR_UNABLE_TO_CONNECT_TO_SERVER, STR_NONE);
|
2015-10-27 04:43:33 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-06-01 23:58:21 +02:00
|
|
|
break;
|
|
|
|
}
|
2015-10-27 04:43:33 +01:00
|
|
|
case NETWORK_STATUS_CONNECTED:
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2015-10-27 04:43:33 +01:00
|
|
|
if (!ProcessConnection(server_connection)) {
|
2016-05-21 17:12:40 +02:00
|
|
|
// Do not show disconnect message window when password window closed/canceled
|
2016-05-28 20:03:57 +02:00
|
|
|
if (server_connection.AuthStatus == NETWORK_AUTH_REQUIREPASSWORD) {
|
2015-11-23 21:07:18 +01:00
|
|
|
window_network_status_close();
|
|
|
|
} else {
|
2016-02-19 17:17:10 +01:00
|
|
|
char str_disconnected[256];
|
|
|
|
|
2016-05-28 20:03:57 +02:00
|
|
|
if (server_connection.GetLastDisconnectReason()) {
|
|
|
|
const char * disconnect_reason = server_connection.GetLastDisconnectReason();
|
2016-02-19 17:17:10 +01:00
|
|
|
format_string(str_disconnected, STR_MULTIPLAYER_DISCONNECTED_WITH_REASON, &disconnect_reason);
|
|
|
|
} else {
|
|
|
|
format_string(str_disconnected, STR_MULTIPLAYER_DISCONNECTED_NO_REASON, NULL);
|
2016-02-18 17:43:47 +01:00
|
|
|
}
|
2016-02-19 17:17:10 +01:00
|
|
|
|
2016-03-23 00:27:49 +01:00
|
|
|
window_network_status_open(str_disconnected, NULL);
|
2015-11-23 21:07:18 +01:00
|
|
|
}
|
2015-09-05 19:46:13 +02:00
|
|
|
Close();
|
|
|
|
}
|
2015-10-27 04:43:33 +01:00
|
|
|
ProcessGameCommandQueue();
|
|
|
|
|
|
|
|
// Check synchronisation
|
2016-04-23 19:07:07 +02:00
|
|
|
if (!_desynchronised && !CheckSRAND(gCurrentTicks, gScenarioSrand0)) {
|
2015-10-27 04:43:33 +01:00
|
|
|
_desynchronised = true;
|
2016-02-18 14:52:02 +01:00
|
|
|
char str_desync[256];
|
2016-02-18 17:43:47 +01:00
|
|
|
format_string(str_desync, STR_MULTIPLAYER_DESYNC, NULL);
|
2016-03-23 00:27:49 +01:00
|
|
|
window_network_status_open(str_desync, NULL);
|
2015-10-27 04:43:33 +01:00
|
|
|
if (!gConfigNetwork.stay_connected) {
|
|
|
|
Close();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2015-08-14 17:59:27 +02:00
|
|
|
}
|
2015-07-08 03:21:05 +02:00
|
|
|
}
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
std::vector<std::unique_ptr<NetworkPlayer>>::iterator Network::GetPlayerIteratorByID(uint8 id)
|
|
|
|
{
|
2015-07-17 02:24:39 +02:00
|
|
|
auto it = std::find_if(player_list.begin(), player_list.end(), [&id](std::unique_ptr<NetworkPlayer> const& player) { return player->id == id; });
|
|
|
|
if (it != player_list.end()) {
|
2016-01-20 23:45:09 +01:00
|
|
|
return it;
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
2016-01-20 23:45:09 +01:00
|
|
|
return player_list.end();
|
|
|
|
}
|
|
|
|
|
|
|
|
NetworkPlayer* Network::GetPlayerByID(uint8 id)
|
|
|
|
{
|
|
|
|
auto it = GetPlayerIteratorByID(id);
|
|
|
|
if (it != player_list.end()) {
|
|
|
|
return it->get();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<std::unique_ptr<NetworkGroup>>::iterator Network::GetGroupIteratorByID(uint8 id)
|
|
|
|
{
|
2016-05-28 20:03:57 +02:00
|
|
|
auto it = std::find_if(group_list.begin(), group_list.end(), [&id](std::unique_ptr<NetworkGroup> const& group) { return group->Id == id; });
|
2016-01-20 23:45:09 +01:00
|
|
|
if (it != group_list.end()) {
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
return group_list.end();
|
|
|
|
}
|
|
|
|
|
|
|
|
NetworkGroup* Network::GetGroupByID(uint8 id)
|
|
|
|
{
|
|
|
|
auto it = GetGroupIteratorByID(id);
|
|
|
|
if (it != group_list.end()) {
|
|
|
|
return it->get();
|
|
|
|
}
|
|
|
|
return nullptr;
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
|
|
|
|
2015-07-19 01:57:42 +02:00
|
|
|
const char* Network::FormatChat(NetworkPlayer* fromplayer, const char* text)
|
|
|
|
{
|
|
|
|
static char formatted[1024];
|
2015-08-07 17:11:10 +02:00
|
|
|
char* lineCh = formatted;
|
2015-07-24 01:22:03 +02:00
|
|
|
formatted[0] = 0;
|
2015-07-19 01:57:42 +02:00
|
|
|
if (fromplayer) {
|
2015-08-07 17:11:10 +02:00
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_OUTLINE);
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_BABYBLUE);
|
2016-05-24 00:20:41 +02:00
|
|
|
safe_strcpy(lineCh, (const char*)fromplayer->name.c_str(), fromplayer->name.size() + 1);
|
2015-08-07 17:11:10 +02:00
|
|
|
strcat(lineCh, ": ");
|
2015-11-01 08:50:44 +01:00
|
|
|
lineCh = strchr(lineCh, '\0');
|
2015-07-19 01:57:42 +02:00
|
|
|
}
|
2015-11-01 08:50:44 +01:00
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_OUTLINE);
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_WHITE);
|
2016-03-01 05:33:46 +01:00
|
|
|
char* ptrtext = lineCh;
|
2016-01-18 20:49:52 +01:00
|
|
|
safe_strcpy(lineCh, text, 800);
|
2016-03-01 05:33:46 +01:00
|
|
|
utf8_remove_format_codes((utf8*)ptrtext, true);
|
2015-07-19 01:57:42 +02:00
|
|
|
return formatted;
|
|
|
|
}
|
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
void Network::SendPacketToClients(NetworkPacket& packet, bool front)
|
2015-07-19 01:57:42 +02:00
|
|
|
{
|
|
|
|
for (auto it = client_connection_list.begin(); it != client_connection_list.end(); it++) {
|
2015-11-04 00:31:09 +01:00
|
|
|
(*it)->QueuePacket(std::move(NetworkPacket::Duplicate(packet)), front);
|
2015-07-19 01:57:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-30 16:34:17 +02:00
|
|
|
bool Network::CheckSRAND(uint32 tick, uint32 srand0)
|
|
|
|
{
|
2015-08-16 00:19:15 +02:00
|
|
|
if (server_srand0_tick == 0)
|
|
|
|
return true;
|
|
|
|
|
2015-08-20 04:34:52 +02:00
|
|
|
if (tick > server_srand0_tick) {
|
2015-08-16 00:19:15 +02:00
|
|
|
server_srand0_tick = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-30 16:34:17 +02:00
|
|
|
if (tick == server_srand0_tick) {
|
|
|
|
server_srand0_tick = 0;
|
2016-07-24 21:32:57 +02:00
|
|
|
// Check that the server and client sprite hashes match
|
|
|
|
const bool sprites_mismatch = server_sprite_hash[0] != '\0' && strcmp(sprite_checksum(), server_sprite_hash);
|
|
|
|
// Check PRNG values and sprite hashes, if exist
|
|
|
|
if ((srand0 != server_srand0) || sprites_mismatch) {
|
2015-07-30 16:34:17 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-11-02 01:28:53 +01:00
|
|
|
void Network::KickPlayer(int playerId)
|
|
|
|
{
|
|
|
|
for(auto it = client_connection_list.begin(); it != client_connection_list.end(); it++) {
|
2016-05-28 20:03:57 +02:00
|
|
|
if ((*it)->Player->id == playerId) {
|
2015-11-02 01:28:53 +01:00
|
|
|
// Disconnect the client gracefully
|
2016-05-28 20:03:57 +02:00
|
|
|
(*it)->SetLastDisconnectReason(STR_MULTIPLAYER_KICKED);
|
2016-02-18 14:52:02 +01:00
|
|
|
char str_disconnect_msg[256];
|
2016-02-19 17:17:10 +01:00
|
|
|
format_string(str_disconnect_msg, STR_MULTIPLAYER_KICKED_REASON, NULL);
|
2016-02-18 14:52:02 +01:00
|
|
|
Server_Send_SETDISCONNECTMSG(*(*it), str_disconnect_msg);
|
2016-06-01 23:58:21 +02:00
|
|
|
(*it)->Socket->Disconnect();
|
2015-11-02 01:28:53 +01:00
|
|
|
(*it)->SendQueuedPackets();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::SetPassword(const char* password)
|
|
|
|
{
|
2016-05-27 21:38:23 +02:00
|
|
|
Network::password = password == nullptr ? "" : password;
|
2015-11-04 00:31:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::ShutdownClient()
|
|
|
|
{
|
|
|
|
if (GetMode() == NETWORK_MODE_CLIENT) {
|
2016-06-01 23:58:21 +02:00
|
|
|
server_connection.Socket->Disconnect();
|
2015-11-04 00:31:09 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-08 03:12:12 +01:00
|
|
|
std::string Network::GenerateAdvertiseKey()
|
2015-11-04 00:31:09 +01:00
|
|
|
{
|
2015-11-08 03:12:12 +01:00
|
|
|
// Generate a string of 16 random hex characters (64-integer key as a hex formatted string)
|
|
|
|
static char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
|
|
|
|
char key[17];
|
|
|
|
for (int i = 0; i < 16; i++) {
|
2015-12-14 23:46:36 +01:00
|
|
|
int hexCharIndex = util_rand() % Util::CountOf(hexChars);
|
2015-11-08 03:12:12 +01:00
|
|
|
key[i] = hexChars[hexCharIndex];
|
|
|
|
}
|
2015-12-14 23:46:36 +01:00
|
|
|
key[Util::CountOf(key) - 1] = 0;
|
2015-11-08 03:12:12 +01:00
|
|
|
|
|
|
|
return key;
|
|
|
|
}
|
2015-11-08 00:56:16 +01:00
|
|
|
|
2015-11-08 03:12:12 +01:00
|
|
|
const char *Network::GetMasterServerUrl()
|
|
|
|
{
|
|
|
|
if (str_is_null_or_empty(gConfigNetwork.master_server_url)) {
|
|
|
|
return OPENRCT2_MASTER_SERVER_URL;
|
|
|
|
} else {
|
|
|
|
return gConfigNetwork.master_server_url;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::AdvertiseRegister()
|
|
|
|
{
|
2015-11-04 00:31:09 +01:00
|
|
|
#ifndef DISABLE_HTTP
|
2015-11-08 03:12:12 +01:00
|
|
|
last_advertise_time = SDL_GetTicks();
|
|
|
|
|
|
|
|
// Send the registration request
|
2015-11-08 23:03:35 +01:00
|
|
|
http_json_request request;
|
|
|
|
request.url = GetMasterServerUrl();
|
|
|
|
request.method = HTTP_METHOD_POST;
|
|
|
|
|
|
|
|
json_t *body = json_object();
|
2015-11-20 19:48:40 +01:00
|
|
|
json_object_set_new(body, "key", json_string(advertise_key.c_str()));
|
|
|
|
json_object_set_new(body, "port", json_integer(listening_port));
|
2015-11-08 23:03:35 +01:00
|
|
|
request.body = body;
|
|
|
|
|
|
|
|
http_request_json_async(&request, [](http_json_response *response) -> void {
|
2015-11-08 03:12:12 +01:00
|
|
|
if (response == NULL) {
|
|
|
|
log_warning("Unable to connect to master server");
|
|
|
|
return;
|
2015-11-08 00:56:16 +01:00
|
|
|
}
|
|
|
|
|
2015-11-08 03:12:12 +01:00
|
|
|
json_t *jsonStatus = json_object_get(response->root, "status");
|
|
|
|
if (json_is_integer(jsonStatus)) {
|
|
|
|
int status = (int)json_integer_value(jsonStatus);
|
|
|
|
if (status == MASTER_SERVER_STATUS_OK) {
|
|
|
|
json_t *jsonToken = json_object_get(response->root, "token");
|
|
|
|
if (json_is_string(jsonToken)) {
|
|
|
|
gNetwork.advertise_token = json_string_value(jsonToken);
|
|
|
|
gNetwork.advertise_status = ADVERTISE_STATUS_REGISTERED;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const char *message = "Invalid response from server";
|
|
|
|
json_t *jsonMessage = json_object_get(response->root, "message");
|
|
|
|
if (json_is_string(jsonMessage)) {
|
|
|
|
message = json_string_value(jsonMessage);
|
|
|
|
}
|
|
|
|
log_warning("Unable to advertise: %s", message);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
http_request_json_dispose(response);
|
|
|
|
});
|
2015-11-08 23:03:35 +01:00
|
|
|
|
|
|
|
json_decref(body);
|
2015-11-08 03:12:12 +01:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::AdvertiseHeartbeat()
|
|
|
|
{
|
|
|
|
#ifndef DISABLE_HTTP
|
|
|
|
// Send the heartbeat request
|
2015-11-09 00:29:52 +01:00
|
|
|
http_json_request request;
|
|
|
|
request.url = GetMasterServerUrl();
|
|
|
|
request.method = HTTP_METHOD_PUT;
|
2015-11-08 03:12:12 +01:00
|
|
|
|
2015-11-09 00:29:52 +01:00
|
|
|
json_t *body = json_object();
|
2015-11-20 19:48:40 +01:00
|
|
|
json_object_set_new(body, "token", json_string(advertise_token.c_str()));
|
|
|
|
json_object_set_new(body, "players", json_integer(network_get_num_players()));
|
2015-11-08 03:12:12 +01:00
|
|
|
|
2015-11-09 00:29:52 +01:00
|
|
|
json_t *gameInfo = json_object();
|
2016-06-09 13:32:25 +02:00
|
|
|
json_object_set_new(gameInfo, "mapSize", json_integer(gMapSize - 2));
|
2016-04-23 12:03:18 +02:00
|
|
|
json_object_set_new(gameInfo, "day", json_integer(gDateMonthTicks));
|
|
|
|
json_object_set_new(gameInfo, "month", json_integer(gDateMonthsElapsed));
|
2016-04-23 02:00:00 +02:00
|
|
|
json_object_set_new(gameInfo, "guests", json_integer(gNumGuestsInPark));
|
2016-04-23 02:50:12 +02:00
|
|
|
json_object_set_new(gameInfo, "parkValue", json_integer(gParkValue));
|
2016-04-23 01:51:22 +02:00
|
|
|
if (!(gParkFlags & PARK_FLAGS_NO_MONEY)) {
|
2016-04-23 02:58:54 +02:00
|
|
|
money32 cash = DECRYPT_MONEY(gCashEncrypted);
|
2015-11-20 19:48:40 +01:00
|
|
|
json_object_set_new(gameInfo, "cash", json_integer(cash));
|
2015-11-09 00:29:52 +01:00
|
|
|
}
|
2015-11-08 23:03:35 +01:00
|
|
|
|
2015-11-20 19:48:40 +01:00
|
|
|
json_object_set_new(body, "gameInfo", gameInfo);
|
2015-11-09 00:29:52 +01:00
|
|
|
request.body = body;
|
|
|
|
|
|
|
|
gNetwork.last_heartbeat_time = SDL_GetTicks();
|
2015-11-08 23:03:35 +01:00
|
|
|
http_request_json_async(&request, [](http_json_response *response) -> void {
|
2015-11-08 03:12:12 +01:00
|
|
|
if (response == NULL) {
|
|
|
|
log_warning("Unable to connect to master server");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
json_t *jsonStatus = json_object_get(response->root, "status");
|
|
|
|
if (json_is_integer(jsonStatus)) {
|
|
|
|
int status = (int)json_integer_value(jsonStatus);
|
|
|
|
if (status == MASTER_SERVER_STATUS_OK) {
|
|
|
|
// Master server has successfully updated our server status
|
|
|
|
} else if (status == MASTER_SERVER_STATUS_INVALID_TOKEN) {
|
|
|
|
gNetwork.advertise_status = ADVERTISE_STATUS_UNREGISTERED;
|
|
|
|
log_warning("Master server heartbeat failed: Invalid Token");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
http_request_json_dispose(response);
|
|
|
|
});
|
2015-11-09 00:29:52 +01:00
|
|
|
|
|
|
|
json_decref(body);
|
2015-11-04 00:31:09 +01:00
|
|
|
#endif
|
2015-11-02 01:28:53 +01:00
|
|
|
}
|
|
|
|
|
2016-01-22 04:32:51 +01:00
|
|
|
NetworkGroup* Network::AddGroup()
|
|
|
|
{
|
|
|
|
NetworkGroup* addedgroup = nullptr;
|
|
|
|
int newid = -1;
|
|
|
|
// Find first unused group id
|
|
|
|
for (int id = 0; id < 255; id++) {
|
2016-05-21 17:12:40 +02:00
|
|
|
if (std::find_if(group_list.begin(), group_list.end(), [&id](std::unique_ptr<NetworkGroup> const& group) {
|
2016-05-28 20:03:57 +02:00
|
|
|
return group->Id == id;
|
2016-05-21 17:12:40 +02:00
|
|
|
}) == group_list.end()) {
|
2016-01-22 04:32:51 +01:00
|
|
|
newid = id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (newid != -1) {
|
|
|
|
std::unique_ptr<NetworkGroup> group(new NetworkGroup); // change to make_unique in c++14
|
2016-05-28 20:03:57 +02:00
|
|
|
group->Id = newid;
|
2016-01-22 04:32:51 +01:00
|
|
|
group->SetName("Group #" + std::to_string(newid));
|
|
|
|
addedgroup = group.get();
|
|
|
|
group_list.push_back(std::move(group));
|
|
|
|
}
|
|
|
|
return addedgroup;
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::RemoveGroup(uint8 id)
|
|
|
|
{
|
|
|
|
auto group = GetGroupIteratorByID(id);
|
|
|
|
if (group != group_list.end()) {
|
|
|
|
group_list.erase(group);
|
|
|
|
}
|
2016-05-27 00:52:40 +02:00
|
|
|
|
|
|
|
if (GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
_userManager.UnsetUsersOfGroup(id);
|
|
|
|
_userManager.Save();
|
2016-05-26 13:50:04 +02:00
|
|
|
}
|
2016-01-22 07:32:40 +01:00
|
|
|
}
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
uint8 Network::GetGroupIDByHash(const std::string &keyhash)
|
|
|
|
{
|
2016-05-27 00:52:40 +02:00
|
|
|
const NetworkUser * networkUser = _userManager.GetUserByHash(keyhash);
|
|
|
|
|
|
|
|
uint8 groupId = GetDefaultGroup();
|
|
|
|
if (networkUser != nullptr && networkUser->GroupId.HasValue()) {
|
|
|
|
groupId = networkUser->GroupId.GetValue();
|
2016-05-19 10:23:42 +02:00
|
|
|
}
|
2016-05-27 00:52:40 +02:00
|
|
|
return groupId;
|
2016-05-19 10:23:42 +02:00
|
|
|
}
|
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
uint8 Network::GetDefaultGroup()
|
|
|
|
{
|
|
|
|
return default_group;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::SetDefaultGroup(uint8 id)
|
|
|
|
{
|
|
|
|
if (GetGroupByID(id)) {
|
|
|
|
default_group = id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-24 02:05:53 +01:00
|
|
|
void Network::SaveGroups()
|
|
|
|
{
|
|
|
|
if (GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
utf8 path[MAX_PATH];
|
|
|
|
|
|
|
|
platform_get_user_directory(path, NULL);
|
2016-05-21 00:16:28 +02:00
|
|
|
strcat(path, "groups.json");
|
2016-01-24 02:05:53 +01:00
|
|
|
|
2016-05-21 00:16:28 +02:00
|
|
|
json_t * jsonGroupsCfg = json_object();
|
|
|
|
json_t * jsonGroups = json_array();
|
2016-01-24 02:05:53 +01:00
|
|
|
for (auto it = group_list.begin(); it != group_list.end(); it++) {
|
2016-05-21 00:16:28 +02:00
|
|
|
json_array_append_new(jsonGroups, (*it)->ToJson());
|
|
|
|
}
|
|
|
|
json_object_set_new(jsonGroupsCfg, "default_group", json_integer(default_group));
|
|
|
|
json_object_set_new(jsonGroupsCfg, "groups", jsonGroups);
|
|
|
|
bool result;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
Json::WriteToFile(path, jsonGroupsCfg, JSON_INDENT(4) | JSON_PRESERVE_ORDER);
|
|
|
|
result = true;
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
log_error("Unable to save %s: %s", path, ex.GetMessage());
|
|
|
|
result = false;
|
2016-01-24 02:05:53 +01:00
|
|
|
}
|
|
|
|
|
2016-05-21 00:16:28 +02:00
|
|
|
json_decref(jsonGroupsCfg);
|
2016-01-24 02:05:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-04 18:50:09 +02:00
|
|
|
void Network::SetupDefaultGroups()
|
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkGroup> admin(new NetworkGroup()); // change to make_unique in c++14
|
|
|
|
admin->SetName("Admin");
|
|
|
|
admin->ActionsAllowed.fill(0xFF);
|
|
|
|
admin->Id = 0;
|
|
|
|
group_list.push_back(std::move(admin));
|
|
|
|
std::unique_ptr<NetworkGroup> spectator(new NetworkGroup()); // change to make_unique in c++14
|
|
|
|
spectator->SetName("Spectator");
|
|
|
|
spectator->ToggleActionPermission(0); // Chat
|
|
|
|
spectator->Id = 1;
|
|
|
|
group_list.push_back(std::move(spectator));
|
|
|
|
std::unique_ptr<NetworkGroup> user(new NetworkGroup()); // change to make_unique in c++14
|
|
|
|
user->SetName("User");
|
|
|
|
user->ActionsAllowed.fill(0xFF);
|
|
|
|
user->ToggleActionPermission(15); // Kick Player
|
|
|
|
user->ToggleActionPermission(16); // Modify Groups
|
|
|
|
user->ToggleActionPermission(17); // Set Player Group
|
|
|
|
user->ToggleActionPermission(18); // Cheat
|
|
|
|
user->Id = 2;
|
|
|
|
group_list.push_back(std::move(user));
|
|
|
|
SetDefaultGroup(1);
|
|
|
|
}
|
|
|
|
|
2016-01-24 02:05:53 +01:00
|
|
|
void Network::LoadGroups()
|
|
|
|
{
|
|
|
|
group_list.clear();
|
|
|
|
|
|
|
|
utf8 path[MAX_PATH];
|
|
|
|
|
|
|
|
platform_get_user_directory(path, NULL);
|
2016-05-21 00:16:28 +02:00
|
|
|
strcat(path, "groups.json");
|
2016-01-24 02:05:53 +01:00
|
|
|
|
2016-07-04 18:50:09 +02:00
|
|
|
json_t * json = nullptr;
|
|
|
|
try {
|
|
|
|
json = Json::ReadFromFile(path);
|
|
|
|
} catch (const Exception& e) {
|
|
|
|
log_error("Failed to read %s as JSON. Setting default groups. %s", path, e.GetMsg());
|
2016-01-24 02:05:53 +01:00
|
|
|
// Hardcoded permission groups
|
2016-07-04 18:50:09 +02:00
|
|
|
SetupDefaultGroups();
|
2016-01-24 02:05:53 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-21 00:16:28 +02:00
|
|
|
json_t * json_groups = json_object_get(json, "groups");
|
|
|
|
size_t groupCount = (size_t)json_array_size(json_groups);
|
|
|
|
for (size_t i = 0; i < groupCount; i++) {
|
|
|
|
json_t * jsonGroup = json_array_get(json_groups, i);
|
2016-01-24 02:05:53 +01:00
|
|
|
|
2016-05-21 00:16:28 +02:00
|
|
|
std::unique_ptr<NetworkGroup> newgroup(new NetworkGroup(NetworkGroup::FromJson(jsonGroup))); // change to make_unique in c++14
|
2016-01-24 02:05:53 +01:00
|
|
|
group_list.push_back(std::move(newgroup));
|
|
|
|
}
|
2016-05-21 00:16:28 +02:00
|
|
|
json_t * jsonDefaultGroup = json_object_get(json, "default_group");
|
|
|
|
default_group = (uint8)json_integer_value(jsonDefaultGroup);
|
2016-08-08 10:01:52 +02:00
|
|
|
if (GetGroupByID(default_group) == nullptr) {
|
2016-05-21 00:16:28 +02:00
|
|
|
default_group = 0;
|
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
json_decref(json);
|
|
|
|
}
|
|
|
|
|
2016-05-30 15:24:06 +02:00
|
|
|
void Network::BeginChatLog()
|
|
|
|
{
|
|
|
|
utf8 filename[32];
|
|
|
|
time_t timer;
|
|
|
|
struct tm * tmInfo;
|
|
|
|
time(&timer);
|
|
|
|
tmInfo = localtime(&timer);
|
|
|
|
strftime(filename, sizeof(filename), "%Y%m%d-%H%M%S.txt", tmInfo);
|
|
|
|
|
|
|
|
utf8 path[MAX_PATH];
|
2016-05-30 19:03:31 +02:00
|
|
|
platform_get_user_directory(path, "chatlogs");
|
2016-05-30 15:24:06 +02:00
|
|
|
Path::Append(path, sizeof(path), filename);
|
|
|
|
|
|
|
|
_chatLogPath = std::string(path);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::AppendChatLog(const utf8 *text)
|
|
|
|
{
|
2016-05-30 19:01:17 +02:00
|
|
|
if (!gConfigNetwork.log_chat) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-30 15:24:06 +02:00
|
|
|
const utf8 *chatLogPath = _chatLogPath.c_str();
|
|
|
|
|
|
|
|
utf8 directory[MAX_PATH];
|
|
|
|
Path::GetDirectory(directory, sizeof(directory), chatLogPath);
|
|
|
|
if (platform_ensure_directory_exists(directory)) {
|
|
|
|
_chatLogStream = SDL_RWFromFile(chatLogPath, "a");
|
|
|
|
if (_chatLogStream != nullptr) {
|
|
|
|
utf8 buffer[256];
|
|
|
|
|
|
|
|
time_t timer;
|
|
|
|
struct tm * tmInfo;
|
|
|
|
time(&timer);
|
|
|
|
tmInfo = localtime(&timer);
|
|
|
|
strftime(buffer, sizeof(buffer), "[%Y/%m/%d %H:%M:%S] ", tmInfo);
|
|
|
|
|
|
|
|
String::Append(buffer, sizeof(buffer), text);
|
2016-06-09 13:30:32 +02:00
|
|
|
utf8_remove_formatting(buffer, false);
|
2016-05-30 15:24:06 +02:00
|
|
|
String::Append(buffer, sizeof(buffer), platform_get_new_line());
|
|
|
|
|
|
|
|
SDL_RWwrite(_chatLogStream, buffer, strlen(buffer), 1);
|
|
|
|
SDL_RWclose(_chatLogStream);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::CloseChatLog()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
void Network::Client_Send_TOKEN()
|
|
|
|
{
|
|
|
|
log_verbose("requesting token");
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_TOKEN;
|
2016-05-28 20:03:57 +02:00
|
|
|
server_connection.AuthStatus = NETWORK_AUTH_REQUESTED;
|
2016-05-19 10:23:42 +02:00
|
|
|
server_connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Client_Send_AUTH(const char* name, const char* password, const char* pubkey, const char *sig, size_t sigsize)
|
2015-07-10 21:53:41 +02:00
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2015-07-15 08:23:04 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_AUTH;
|
2016-01-30 22:28:51 +01:00
|
|
|
packet->WriteString(NETWORK_STREAM_ID);
|
2015-07-15 08:23:04 +02:00
|
|
|
packet->WriteString(name);
|
|
|
|
packet->WriteString(password);
|
2016-05-19 10:23:42 +02:00
|
|
|
packet->WriteString(pubkey);
|
|
|
|
assert(sigsize <= (size_t)UINT32_MAX);
|
|
|
|
*packet << (uint32)sigsize;
|
|
|
|
packet->Write((const uint8 *)sig, sigsize);
|
2016-05-28 20:03:57 +02:00
|
|
|
server_connection.AuthStatus = NETWORK_AUTH_REQUESTED;
|
2015-07-15 08:23:04 +02:00
|
|
|
server_connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
void Network::Server_Send_TOKEN(NetworkConnection& connection)
|
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-05-28 20:03:57 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_TOKEN << (uint32)connection.Challenge.size();
|
|
|
|
packet->Write(connection.Challenge.data(), connection.Challenge.size());
|
2016-05-19 10:23:42 +02:00
|
|
|
connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2015-11-02 04:12:14 +01:00
|
|
|
void Network::Server_Send_AUTH(NetworkConnection& connection)
|
|
|
|
{
|
|
|
|
uint8 new_playerid = 0;
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.Player) {
|
|
|
|
new_playerid = connection.Player->id;
|
2015-11-02 04:12:14 +01:00
|
|
|
}
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-05-28 20:03:57 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_AUTH << (uint32)connection.AuthStatus << (uint8)new_playerid;
|
|
|
|
if (connection.AuthStatus == NETWORK_AUTH_BADVERSION) {
|
2016-04-19 00:08:01 +02:00
|
|
|
packet->WriteString(NETWORK_STREAM_ID);
|
|
|
|
}
|
2015-11-02 04:12:14 +01:00
|
|
|
connection.QueuePacket(std::move(packet));
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.AuthStatus != NETWORK_AUTH_OK && connection.AuthStatus != NETWORK_AUTH_REQUIREPASSWORD) {
|
2015-11-02 04:12:14 +01:00
|
|
|
connection.SendQueuedPackets();
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2015-11-02 04:12:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-31 16:14:44 +02:00
|
|
|
void Network::Server_Send_MAP(NetworkConnection* connection)
|
2015-07-15 08:23:04 +02:00
|
|
|
{
|
2016-01-20 15:30:27 +01:00
|
|
|
bool RLEState = gUseRLE;
|
|
|
|
gUseRLE = false;
|
2016-02-02 22:11:19 +01:00
|
|
|
FILE* temp = tmpfile();
|
|
|
|
if (!temp) {
|
|
|
|
log_warning("Failed to create temporary file to save map.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
SDL_RWops* rw = SDL_RWFromFP(temp, SDL_TRUE);
|
2015-07-31 16:14:44 +02:00
|
|
|
scenario_save_network(rw);
|
2016-01-20 15:30:27 +01:00
|
|
|
gUseRLE = RLEState;
|
2015-07-15 08:23:04 +02:00
|
|
|
int size = (int)SDL_RWtell(rw);
|
2016-02-02 22:11:19 +01:00
|
|
|
std::vector<uint8> buffer(size);
|
|
|
|
SDL_RWseek(rw, 0, RW_SEEK_SET);
|
|
|
|
if (SDL_RWread(rw, &buffer[0], size, 1) == 0) {
|
|
|
|
log_warning("Failed to read temporary map file into memory.");
|
2016-02-02 22:37:26 +01:00
|
|
|
SDL_RWclose(rw);
|
2016-02-02 22:11:19 +01:00
|
|
|
return;
|
|
|
|
}
|
2016-04-20 09:24:02 +02:00
|
|
|
size_t chunksize = 65000;
|
2016-02-26 20:49:01 +01:00
|
|
|
size_t out_size = size;
|
2016-01-20 11:22:35 +01:00
|
|
|
unsigned char *compressed = util_zlib_deflate(&buffer[0], size, &out_size);
|
2016-01-24 21:12:20 +01:00
|
|
|
unsigned char *header;
|
|
|
|
if (compressed != NULL)
|
|
|
|
{
|
|
|
|
header = (unsigned char *)_strdup("open2_sv6_zlib");
|
|
|
|
size_t header_len = strlen((char *)header) + 1; // account for null terminator
|
|
|
|
header = (unsigned char *)realloc(header, header_len + out_size);
|
2016-07-29 22:25:23 +02:00
|
|
|
if (header == nullptr) {
|
|
|
|
log_error("Failed to allocate %u bytes.", header_len + out_size);
|
2016-07-30 10:12:48 +02:00
|
|
|
connection->SetLastDisconnectReason(STR_MULTIPLAYER_CONNECTION_CLOSED);
|
|
|
|
connection->Socket->Disconnect();
|
2016-08-03 07:39:55 +02:00
|
|
|
free(compressed);
|
2016-07-29 22:25:23 +02:00
|
|
|
return;
|
|
|
|
}
|
2016-01-24 21:12:20 +01:00
|
|
|
memcpy(&header[header_len], compressed, out_size);
|
|
|
|
out_size += header_len;
|
|
|
|
free(compressed);
|
|
|
|
log_verbose("Sending map of size %u bytes, compressed to %u bytes", size, out_size);
|
|
|
|
} else {
|
|
|
|
log_warning("Failed to compress the data, falling back to non-compressed sv6.");
|
|
|
|
header = (unsigned char *)malloc(size);
|
2016-07-29 22:25:23 +02:00
|
|
|
if (header == nullptr) {
|
|
|
|
log_error("Failed to allocate %u bytes.", size);
|
2016-07-30 10:12:48 +02:00
|
|
|
connection->SetLastDisconnectReason(STR_MULTIPLAYER_CONNECTION_CLOSED);
|
|
|
|
connection->Socket->Disconnect();
|
2016-07-29 22:25:23 +02:00
|
|
|
return;
|
|
|
|
}
|
2016-01-24 21:12:20 +01:00
|
|
|
out_size = size;
|
|
|
|
memcpy(header, &buffer[0], size);
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
for (size_t i = 0; i < out_size; i += chunksize) {
|
2016-01-20 11:22:35 +01:00
|
|
|
int datasize = (std::min)(chunksize, out_size - i);
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-01-20 11:22:35 +01:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_MAP << (uint32)out_size << (uint32)i;
|
|
|
|
packet->Write(&header[i], datasize);
|
2015-07-31 16:14:44 +02:00
|
|
|
if (connection) {
|
|
|
|
connection->QueuePacket(std::move(packet));
|
|
|
|
} else {
|
|
|
|
SendPacketToClients(*packet);
|
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
2016-01-20 11:22:35 +01:00
|
|
|
free(header);
|
2015-07-15 08:23:04 +02:00
|
|
|
SDL_RWclose(rw);
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
void Network::Client_Send_CHAT(const char* text)
|
2015-07-10 21:53:41 +02:00
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2015-07-15 06:40:22 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_CHAT;
|
2015-11-04 00:31:09 +01:00
|
|
|
packet->WriteString(text);
|
2015-07-15 08:23:04 +02:00
|
|
|
server_connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Server_Send_CHAT(const char* text)
|
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2015-07-15 08:23:04 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_CHAT;
|
2015-11-04 00:31:09 +01:00
|
|
|
packet->WriteString(text);
|
2015-07-19 01:57:42 +02:00
|
|
|
SendPacketToClients(*packet);
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
2015-07-24 01:22:03 +02:00
|
|
|
void Network::Client_Send_GAMECMD(uint32 eax, uint32 ebx, uint32 ecx, uint32 edx, uint32 esi, uint32 edi, uint32 ebp, uint8 callback)
|
2015-07-10 21:53:41 +02:00
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-05-21 17:12:40 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_GAMECMD << (uint32)gCurrentTicks << eax << (ebx | GAME_COMMAND_FLAG_NETWORKED)
|
|
|
|
<< ecx << edx << esi << edi << ebp << callback;
|
2015-07-15 08:23:04 +02:00
|
|
|
server_connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2015-07-24 01:22:03 +02:00
|
|
|
void Network::Server_Send_GAMECMD(uint32 eax, uint32 ebx, uint32 ecx, uint32 edx, uint32 esi, uint32 edi, uint32 ebp, uint8 playerid, uint8 callback)
|
2015-07-15 08:23:04 +02:00
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-05-21 17:12:40 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_GAMECMD << (uint32)gCurrentTicks << eax << (ebx | GAME_COMMAND_FLAG_NETWORKED)
|
|
|
|
<< ecx << edx << esi << edi << ebp << playerid << callback;
|
2015-07-19 01:57:42 +02:00
|
|
|
SendPacketToClients(*packet);
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
void Network::Server_Send_TICK()
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
2015-11-04 00:31:09 +01:00
|
|
|
last_tick_sent_time = SDL_GetTicks();
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-04-23 19:07:07 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_TICK << (uint32)gCurrentTicks << (uint32)gScenarioSrand0;
|
2016-07-24 21:32:57 +02:00
|
|
|
uint32 flags = 0;
|
|
|
|
// Simple counter which limits how often a sprite checksum gets sent.
|
2016-07-27 15:09:30 +02:00
|
|
|
// This can get somewhat expensive, so we don't want to push it every tick in release,
|
2016-07-24 21:32:57 +02:00
|
|
|
// but debug version can check more often.
|
|
|
|
static int checksum_counter = 0;
|
|
|
|
checksum_counter++;
|
|
|
|
if (checksum_counter >= 100) {
|
|
|
|
checksum_counter = 0;
|
|
|
|
flags |= NETWORK_TICK_FLAG_CHECKSUMS;
|
|
|
|
}
|
|
|
|
// Send flags always, so we can understand packet structure on the other end,
|
|
|
|
// and allow for some expansion.
|
|
|
|
*packet << flags;
|
|
|
|
if (flags & NETWORK_TICK_FLAG_CHECKSUMS) {
|
|
|
|
packet->WriteString(sprite_checksum());
|
|
|
|
}
|
2015-07-19 01:57:42 +02:00
|
|
|
SendPacketToClients(*packet);
|
2015-07-16 19:32:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Server_Send_PLAYERLIST()
|
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-01-22 07:32:40 +01:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_PLAYERLIST << (uint8)player_list.size();
|
2015-07-16 19:32:43 +02:00
|
|
|
for (unsigned int i = 0; i < player_list.size(); i++) {
|
2016-01-22 04:32:51 +01:00
|
|
|
player_list[i]->Write(*packet);
|
2015-07-16 19:32:43 +02:00
|
|
|
}
|
2015-07-19 01:57:42 +02:00
|
|
|
SendPacketToClients(*packet);
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
|
2015-07-17 02:24:39 +02:00
|
|
|
void Network::Client_Send_PING()
|
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2015-07-17 02:24:39 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_PING;
|
|
|
|
server_connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Server_Send_PING()
|
|
|
|
{
|
2015-11-04 00:31:09 +01:00
|
|
|
last_ping_sent_time = SDL_GetTicks();
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2015-07-17 02:24:39 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_PING;
|
|
|
|
for (auto it = client_connection_list.begin(); it != client_connection_list.end(); it++) {
|
2016-05-28 20:03:57 +02:00
|
|
|
(*it)->PingTime = SDL_GetTicks();
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
2015-11-04 00:31:09 +01:00
|
|
|
SendPacketToClients(*packet, true);
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Server_Send_PINGLIST()
|
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-01-22 07:32:40 +01:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_PINGLIST << (uint8)player_list.size();
|
2015-07-17 02:24:39 +02:00
|
|
|
for (unsigned int i = 0; i < player_list.size(); i++) {
|
|
|
|
*packet << player_list[i]->id << player_list[i]->ping;
|
|
|
|
}
|
2015-07-19 01:57:42 +02:00
|
|
|
SendPacketToClients(*packet);
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
|
|
|
|
2015-11-01 08:50:44 +01:00
|
|
|
void Network::Server_Send_SETDISCONNECTMSG(NetworkConnection& connection, const char* msg)
|
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_SETDISCONNECTMSG;
|
|
|
|
packet->WriteString(msg);
|
|
|
|
connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
void Network::Server_Send_GAMEINFO(NetworkConnection& connection)
|
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_GAMEINFO;
|
|
|
|
#ifndef DISABLE_HTTP
|
|
|
|
json_t* obj = json_object();
|
2015-11-20 19:48:40 +01:00
|
|
|
json_object_set_new(obj, "name", json_string(gConfigNetwork.server_name));
|
|
|
|
json_object_set_new(obj, "requiresPassword", json_boolean(password.size() > 0));
|
2016-01-30 22:28:51 +01:00
|
|
|
json_object_set_new(obj, "version", json_string(NETWORK_STREAM_ID));
|
2015-11-20 19:48:40 +01:00
|
|
|
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));
|
2016-08-14 06:15:45 +02:00
|
|
|
json_object_set_new(obj, "greeting", json_string(gConfigNetwork.server_greeting));
|
2015-11-20 19:48:40 +01:00
|
|
|
json_object_set_new(obj, "dedicated", json_boolean(gOpenRCT2Headless));
|
2015-11-11 23:39:04 +01:00
|
|
|
|
|
|
|
// Provider details
|
|
|
|
json_t* jsonProvider = json_object();
|
2015-11-20 19:48:40 +01:00
|
|
|
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(obj, "provider", jsonProvider);
|
2015-11-11 23:39:04 +01:00
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
packet->WriteString(json_dumps(obj, 0));
|
2015-11-08 23:03:35 +01:00
|
|
|
json_decref(obj);
|
2015-11-04 00:31:09 +01:00
|
|
|
#endif
|
|
|
|
connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
void Network::Server_Send_SHOWERROR(NetworkConnection& connection, rct_string_id title, rct_string_id message)
|
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_SHOWERROR << title << message;
|
|
|
|
connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Server_Send_GROUPLIST(NetworkConnection& connection)
|
2016-01-22 04:32:51 +01:00
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
2016-01-24 02:57:56 +01:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_GROUPLIST << (uint8)group_list.size() << default_group;
|
2016-01-22 07:32:40 +01:00
|
|
|
for (unsigned int i = 0; i < group_list.size(); i++) {
|
|
|
|
group_list[i]->Write(*packet);
|
|
|
|
}
|
|
|
|
connection.QueuePacket(std::move(packet));
|
2016-01-22 04:32:51 +01:00
|
|
|
}
|
|
|
|
|
2016-02-27 14:12:04 +01:00
|
|
|
void Network::Server_Send_EVENT_PLAYER_JOINED(const char *playerName)
|
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_EVENT;
|
|
|
|
*packet << (uint16)SERVER_EVENT_PLAYER_JOINED;
|
|
|
|
packet->WriteString(playerName);
|
|
|
|
SendPacketToClients(*packet);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Server_Send_EVENT_PLAYER_DISCONNECTED(const char *playerName, const char *reason)
|
|
|
|
{
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_EVENT;
|
|
|
|
*packet << (uint16)SERVER_EVENT_PLAYER_DISCONNECTED;
|
|
|
|
packet->WriteString(playerName);
|
|
|
|
packet->WriteString(reason);
|
|
|
|
SendPacketToClients(*packet);
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
bool Network::ProcessConnection(NetworkConnection& connection)
|
2015-07-08 03:21:05 +02:00
|
|
|
{
|
|
|
|
int packetStatus;
|
2015-02-12 12:30:57 +01:00
|
|
|
do {
|
2015-07-10 21:53:41 +02:00
|
|
|
packetStatus = connection.ReadPacket();
|
2015-07-05 17:19:01 +02:00
|
|
|
switch(packetStatus) {
|
2015-11-01 08:50:44 +01:00
|
|
|
case NETWORK_READPACKET_DISCONNECTED:
|
2015-07-10 21:53:41 +02:00
|
|
|
// closed connection or network error
|
2016-05-28 20:03:57 +02:00
|
|
|
if (!connection.GetLastDisconnectReason()) {
|
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_CONNECTION_CLOSED);
|
2015-02-12 12:30:57 +01:00
|
|
|
}
|
2015-11-01 08:50:44 +01:00
|
|
|
return false;
|
2015-07-05 17:19:01 +02:00
|
|
|
break;
|
2015-11-01 08:50:44 +01:00
|
|
|
case NETWORK_READPACKET_SUCCESS:
|
2015-07-05 17:19:01 +02:00
|
|
|
// done reading in packet
|
2016-05-28 20:03:57 +02:00
|
|
|
ProcessPacket(connection, connection.InboundPacket);
|
2016-06-09 19:37:12 +02:00
|
|
|
if (connection.Socket == nullptr) {
|
|
|
|
return false;
|
|
|
|
}
|
2015-07-05 17:19:01 +02:00
|
|
|
break;
|
2015-11-01 08:50:44 +01:00
|
|
|
case NETWORK_READPACKET_MORE_DATA:
|
2015-07-05 17:19:01 +02:00
|
|
|
// more data required to be read
|
|
|
|
break;
|
2015-11-01 08:50:44 +01:00
|
|
|
case NETWORK_READPACKET_NO_DATA:
|
2015-07-10 21:53:41 +02:00
|
|
|
// could not read anything from socket
|
2015-07-05 17:19:01 +02:00
|
|
|
break;
|
|
|
|
}
|
2015-11-01 08:50:44 +01:00
|
|
|
} while (packetStatus == NETWORK_READPACKET_MORE_DATA || packetStatus == NETWORK_READPACKET_SUCCESS);
|
2015-11-02 01:28:53 +01:00
|
|
|
connection.SendQueuedPackets();
|
2015-11-01 08:50:44 +01:00
|
|
|
if (!connection.ReceivedPacketRecently()) {
|
2016-05-28 20:03:57 +02:00
|
|
|
if (!connection.GetLastDisconnectReason()) {
|
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_NO_DATA);
|
2015-11-04 00:31:09 +01:00
|
|
|
}
|
2015-11-01 08:50:44 +01:00
|
|
|
return false;
|
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
return true;
|
2015-07-09 04:19:12 +02:00
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
void Network::ProcessPacket(NetworkConnection& connection, NetworkPacket& packet)
|
2015-02-12 12:30:57 +01:00
|
|
|
{
|
2015-07-15 06:40:22 +02:00
|
|
|
uint32 command;
|
|
|
|
packet >> command;
|
2015-07-15 08:23:04 +02:00
|
|
|
if (command < NETWORK_COMMAND_MAX) {
|
2015-08-16 00:19:15 +02:00
|
|
|
switch (gNetwork.GetMode()) {
|
|
|
|
case NETWORK_MODE_SERVER:
|
2015-07-15 08:23:04 +02:00
|
|
|
if (server_command_handlers[command]) {
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.AuthStatus == NETWORK_AUTH_OK || !packet.CommandRequiresAuth()) {
|
2015-07-15 08:23:04 +02:00
|
|
|
(this->*server_command_handlers[command])(connection, packet);
|
|
|
|
}
|
|
|
|
}
|
2015-08-16 00:19:15 +02:00
|
|
|
break;
|
|
|
|
case NETWORK_MODE_CLIENT:
|
|
|
|
if (client_command_handlers[command]) {
|
|
|
|
(this->*client_command_handlers[command])(connection, packet);
|
|
|
|
}
|
|
|
|
break;
|
2015-07-15 08:23:04 +02:00
|
|
|
}
|
2015-02-12 17:23:49 +01:00
|
|
|
}
|
2015-07-09 04:19:12 +02:00
|
|
|
packet.Clear();
|
2015-07-05 17:19:01 +02:00
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
void Network::ProcessGameCommandQueue()
|
2015-07-05 17:19:01 +02:00
|
|
|
{
|
2016-04-23 03:49:24 +02:00
|
|
|
while (game_command_queue.begin() != game_command_queue.end() && game_command_queue.begin()->tick == gCurrentTicks) {
|
2015-07-10 21:53:41 +02:00
|
|
|
// run all the game commands at the current tick
|
|
|
|
const GameCommand& gc = (*game_command_queue.begin());
|
2015-07-24 01:22:03 +02:00
|
|
|
if (GetPlayerID() == gc.playerid) {
|
|
|
|
game_command_callback = game_command_callback_get_callback(gc.callback);
|
|
|
|
}
|
2016-01-23 00:57:00 +01:00
|
|
|
game_command_playerid = gc.playerid;
|
2016-01-23 21:19:17 +01:00
|
|
|
int command = gc.esi;
|
|
|
|
money32 cost = game_do_command_p(command, (int*)&gc.eax, (int*)&gc.ebx, (int*)&gc.ecx, (int*)&gc.edx, (int*)&gc.esi, (int*)&gc.edi, (int*)&gc.ebp);
|
2016-01-20 23:45:09 +01:00
|
|
|
if (cost != MONEY32_UNDEFINED) {
|
|
|
|
NetworkPlayer* player = GetPlayerByID(gc.playerid);
|
|
|
|
if (player) {
|
2016-05-28 19:29:56 +02:00
|
|
|
player->last_action = NetworkActions::FindCommand(command);
|
2016-01-23 20:32:02 +01:00
|
|
|
player->last_action_time = SDL_GetTicks();
|
2016-01-20 23:45:09 +01:00
|
|
|
player->AddMoneySpent(cost);
|
|
|
|
}
|
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
game_command_queue.erase(game_command_queue.begin());
|
2015-07-05 17:19:01 +02:00
|
|
|
}
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
void Network::AddClient(ITcpSocket * socket)
|
2015-07-07 22:52:41 +02:00
|
|
|
{
|
2015-07-16 19:32:43 +02:00
|
|
|
auto connection = std::unique_ptr<NetworkConnection>(new NetworkConnection); // change to make_unique in c++14
|
2016-05-28 20:03:57 +02:00
|
|
|
connection->Socket = socket;
|
2015-07-16 19:32:43 +02:00
|
|
|
client_connection_list.push_back(std::move(connection));
|
2015-07-07 22:52:41 +02:00
|
|
|
}
|
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
void Network::RemoveClient(std::unique_ptr<NetworkConnection>& connection)
|
2015-07-07 16:09:21 +02:00
|
|
|
{
|
2016-05-28 20:03:57 +02:00
|
|
|
NetworkPlayer* connection_player = connection->Player;
|
2015-07-19 01:57:42 +02:00
|
|
|
if (connection_player) {
|
|
|
|
char text[256];
|
2016-02-19 17:17:10 +01:00
|
|
|
const char * has_disconnected_args[2] = {
|
2016-05-24 00:20:41 +02:00
|
|
|
(char *) connection_player->name.c_str(),
|
2016-05-28 20:03:57 +02:00
|
|
|
connection->GetLastDisconnectReason()
|
2016-02-18 17:43:47 +01:00
|
|
|
};
|
2016-02-19 17:17:10 +01:00
|
|
|
if (has_disconnected_args[1]) {
|
|
|
|
format_string(text, STR_MULTIPLAYER_PLAYER_HAS_DISCONNECTED_WITH_REASON, has_disconnected_args);
|
|
|
|
} else {
|
|
|
|
format_string(text, STR_MULTIPLAYER_PLAYER_HAS_DISCONNECTED_NO_REASON, &(has_disconnected_args[0]));
|
|
|
|
}
|
|
|
|
|
2015-07-19 01:57:42 +02:00
|
|
|
chat_history_add(text);
|
2016-05-28 20:03:57 +02:00
|
|
|
gNetwork.Server_Send_EVENT_PLAYER_DISCONNECTED((char*)connection_player->name.c_str(), connection->GetLastDisconnectReason());
|
2015-07-19 01:57:42 +02:00
|
|
|
}
|
2016-05-21 17:12:40 +02:00
|
|
|
player_list.erase(std::remove_if(player_list.begin(), player_list.end(), [connection_player](std::unique_ptr<NetworkPlayer>& player){
|
|
|
|
return player.get() == connection_player;
|
|
|
|
}), player_list.end());
|
2015-07-16 19:32:43 +02:00
|
|
|
client_connection_list.remove(connection);
|
|
|
|
Server_Send_PLAYERLIST();
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2016-05-25 23:01:10 +02:00
|
|
|
NetworkPlayer* Network::AddPlayer(const utf8 *name, const std::string &keyhash)
|
2015-07-17 02:24:39 +02:00
|
|
|
{
|
2016-01-20 23:45:09 +01:00
|
|
|
NetworkPlayer* addedplayer = nullptr;
|
2015-07-17 02:24:39 +02:00
|
|
|
int newid = -1;
|
|
|
|
if (GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
// Find first unused player id
|
|
|
|
for (int id = 0; id < 255; id++) {
|
2016-05-21 17:12:40 +02:00
|
|
|
if (std::find_if(player_list.begin(), player_list.end(), [&id](std::unique_ptr<NetworkPlayer> const& player) {
|
|
|
|
return player->id == id;
|
|
|
|
}) == player_list.end()) {
|
2015-07-17 02:24:39 +02:00
|
|
|
newid = id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
newid = 0;
|
|
|
|
}
|
|
|
|
if (newid != -1) {
|
2016-05-27 00:52:40 +02:00
|
|
|
std::unique_ptr<NetworkPlayer> player;
|
|
|
|
if (GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
// Load keys host may have added manually
|
|
|
|
_userManager.Load();
|
|
|
|
|
|
|
|
// Check if the key is registered
|
|
|
|
const NetworkUser * networkUser = _userManager.GetUserByHash(keyhash);
|
|
|
|
|
|
|
|
player = std::unique_ptr<NetworkPlayer>(new NetworkPlayer); // change to make_unique in c++14
|
|
|
|
player->id = newid;
|
|
|
|
player->keyhash = keyhash;
|
|
|
|
if (networkUser == nullptr) {
|
|
|
|
player->group = GetDefaultGroup();
|
|
|
|
if (!String::IsNullOrEmpty(name)) {
|
|
|
|
player->SetName(MakePlayerNameUnique(std::string(name)));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
player->group = networkUser->GroupId.GetValueOrDefault(GetDefaultGroup());
|
|
|
|
player->SetName(networkUser->Name);
|
2016-05-25 23:01:10 +02:00
|
|
|
}
|
|
|
|
} else {
|
2016-05-27 00:52:40 +02:00
|
|
|
player = std::unique_ptr<NetworkPlayer>(new NetworkPlayer); // change to make_unique in c++14
|
|
|
|
player->id = newid;
|
|
|
|
player->group = GetDefaultGroup();
|
|
|
|
player->SetName(name);
|
2016-05-25 23:01:10 +02:00
|
|
|
}
|
|
|
|
|
2015-07-17 02:24:39 +02:00
|
|
|
addedplayer = player.get();
|
|
|
|
player_list.push_back(std::move(player));
|
|
|
|
}
|
|
|
|
return addedplayer;
|
|
|
|
}
|
|
|
|
|
2016-05-24 00:20:41 +02:00
|
|
|
std::string Network::MakePlayerNameUnique(const std::string &name)
|
|
|
|
{
|
2016-05-25 23:01:10 +02:00
|
|
|
// Note: Player names are case-insensitive
|
|
|
|
|
2016-05-24 00:20:41 +02:00
|
|
|
std::string new_name = name.substr(0, 31);
|
2016-05-25 23:01:10 +02:00
|
|
|
int counter = 1;
|
|
|
|
bool unique;
|
|
|
|
do {
|
|
|
|
unique = true;
|
|
|
|
|
|
|
|
// Check if there is already a player with this name in the server
|
|
|
|
for (const auto &player : player_list) {
|
|
|
|
if (String::Equals(player->name.c_str(), new_name.c_str(), true)) {
|
|
|
|
unique = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unique) {
|
|
|
|
// Check if there is already a registered player with this name
|
2016-05-27 00:52:40 +02:00
|
|
|
if (_userManager.GetUserByName(new_name) != nullptr) {
|
|
|
|
unique = false;
|
2016-05-25 23:01:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!unique) {
|
|
|
|
// Increment name counter
|
|
|
|
counter++;
|
|
|
|
new_name = name.substr(0, 31) + " #" + std::to_string(counter);
|
|
|
|
}
|
|
|
|
} while (!unique);
|
2016-05-24 00:20:41 +02:00
|
|
|
return new_name;
|
|
|
|
}
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
void Network::Client_Handle_TOKEN(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
2016-05-25 21:46:59 +02:00
|
|
|
utf8 keyPath[MAX_PATH];
|
|
|
|
network_get_private_key_path(keyPath, sizeof(keyPath), gConfigNetwork.player_name);
|
2016-05-19 10:23:42 +02:00
|
|
|
if (!platform_file_exists(keyPath)) {
|
|
|
|
log_error("Key file (%s) was not found. Restart client to re-generate it.", keyPath);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
SDL_RWops *privkey = SDL_RWFromFile(keyPath, "rb");
|
2016-05-21 22:43:59 +02:00
|
|
|
bool ok = key.LoadPrivate(privkey);
|
|
|
|
SDL_RWclose(privkey);
|
|
|
|
if (!ok) {
|
|
|
|
log_error("Failed to load key %s", keyPath);
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_VERIFICATION_FAILURE);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2016-05-21 22:43:59 +02:00
|
|
|
return;
|
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
uint32 challenge_size;
|
|
|
|
packet >> challenge_size;
|
|
|
|
const char *challenge = (const char *)packet.Read(challenge_size);
|
2016-05-21 00:05:11 +02:00
|
|
|
size_t sigsize;
|
2016-05-19 10:23:42 +02:00
|
|
|
char *signature;
|
|
|
|
const std::string pubkey = key.PublicKeyString();
|
2016-05-22 11:29:22 +02:00
|
|
|
this->challenge.resize(challenge_size);
|
|
|
|
memcpy(this->challenge.data(), challenge, challenge_size);
|
|
|
|
ok = key.Sign(this->challenge.data(), this->challenge.size(), &signature, &sigsize);
|
2016-05-21 22:43:59 +02:00
|
|
|
if (!ok) {
|
|
|
|
log_error("Failed to sign server's challenge.");
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_VERIFICATION_FAILURE);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2016-05-21 22:43:59 +02:00
|
|
|
return;
|
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
// 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.
|
|
|
|
key.Unload();
|
|
|
|
Client_Send_AUTH(gConfigNetwork.player_name, "", pubkey.c_str(), signature, sigsize);
|
|
|
|
delete [] signature;
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
2016-06-20 14:46:27 +02:00
|
|
|
uint32 auth_status;
|
|
|
|
packet >> auth_status >> (uint8&)player_id;
|
|
|
|
connection.AuthStatus = (NETWORK_AUTH)auth_status;
|
2016-05-28 20:03:57 +02:00
|
|
|
switch(connection.AuthStatus) {
|
2016-05-30 23:25:43 +02:00
|
|
|
case NETWORK_AUTH_OK:
|
|
|
|
Client_Send_GAMEINFO();
|
|
|
|
break;
|
2015-11-02 01:28:53 +01:00
|
|
|
case NETWORK_AUTH_BADNAME:
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_BAD_PLAYER_NAME);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2015-11-02 01:28:53 +01:00
|
|
|
break;
|
|
|
|
case NETWORK_AUTH_BADVERSION:
|
2016-04-19 00:08:01 +02:00
|
|
|
{
|
|
|
|
const char *version = packet.ReadString();
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_INCORRECT_SOFTWARE_VERSION, &version);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2015-11-02 01:28:53 +01:00
|
|
|
break;
|
2016-04-19 00:08:01 +02:00
|
|
|
}
|
2015-11-02 01:28:53 +01:00
|
|
|
case NETWORK_AUTH_BADPASSWORD:
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_BAD_PASSWORD);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2015-11-02 01:28:53 +01:00
|
|
|
break;
|
2016-05-21 19:26:53 +02:00
|
|
|
case NETWORK_AUTH_VERIFICATIONFAILURE:
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_VERIFICATION_FAILURE);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2016-05-21 19:26:53 +02:00
|
|
|
break;
|
2015-11-04 00:31:09 +01:00
|
|
|
case NETWORK_AUTH_FULL:
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_SERVER_FULL);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2015-11-04 00:31:09 +01:00
|
|
|
break;
|
2015-11-02 04:12:14 +01:00
|
|
|
case NETWORK_AUTH_REQUIREPASSWORD:
|
|
|
|
window_network_status_open_password();
|
|
|
|
break;
|
2016-05-26 16:11:50 +02:00
|
|
|
case NETWORK_AUTH_UNKNOWN_KEY_DISALLOWED:
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_UNKNOWN_KEY_DISALLOWED);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2016-05-26 16:11:50 +02:00
|
|
|
break;
|
2016-05-30 12:28:41 +02:00
|
|
|
default:
|
2016-05-30 23:25:43 +02:00
|
|
|
connection.SetLastDisconnectReason(STR_MULTIPLAYER_INCORRECT_SOFTWARE_VERSION);
|
2016-06-01 23:58:21 +02:00
|
|
|
connection.Socket->Disconnect();
|
2016-05-30 12:28:41 +02:00
|
|
|
break;
|
2015-11-02 01:28:53 +01:00
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
|
2016-05-19 10:23:42 +02:00
|
|
|
void Network::Server_Client_Joined(const char* name, const std::string &keyhash, NetworkConnection& connection)
|
|
|
|
{
|
2016-05-25 23:01:10 +02:00
|
|
|
NetworkPlayer* player = AddPlayer(name, keyhash);
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.Player = player;
|
2016-05-19 10:23:42 +02:00
|
|
|
if (player) {
|
|
|
|
char text[256];
|
2016-05-24 00:20:41 +02:00
|
|
|
const char * player_name = (const char *) player->name.c_str();
|
2016-05-19 10:23:42 +02:00
|
|
|
format_string(text, STR_MULTIPLAYER_PLAYER_HAS_JOINED_THE_GAME, &player_name);
|
|
|
|
chat_history_add(text);
|
|
|
|
Server_Send_MAP(&connection);
|
|
|
|
gNetwork.Server_Send_EVENT_PLAYER_JOINED(player_name);
|
|
|
|
Server_Send_GROUPLIST(connection);
|
|
|
|
Server_Send_PLAYERLIST();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Server_Handle_TOKEN(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
2016-05-22 11:29:22 +02:00
|
|
|
uint8 token_size = 10 + (rand() & 0x7f);
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.Challenge.resize(token_size);
|
2016-05-22 11:29:22 +02:00
|
|
|
for (int i = 0; i < token_size; i++) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.Challenge[i] = (uint8)(rand() & 0xff);
|
2016-05-22 11:29:22 +02:00
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
Server_Send_TOKEN(connection);
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Server_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 08:23:04 +02:00
|
|
|
{
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.AuthStatus != NETWORK_AUTH_OK) {
|
2015-07-16 19:32:43 +02:00
|
|
|
const char* gameversion = packet.ReadString();
|
|
|
|
const char* name = packet.ReadString();
|
|
|
|
const char* password = packet.ReadString();
|
2016-05-19 10:23:42 +02:00
|
|
|
const char *pubkey = (const char *)packet.ReadString();
|
|
|
|
uint32 sigsize;
|
|
|
|
packet >> sigsize;
|
|
|
|
if (pubkey == nullptr) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_VERIFICATIONFAILURE;
|
2016-05-19 10:23:42 +02:00
|
|
|
} else {
|
|
|
|
const char *signature = (const char *)packet.Read(sigsize);
|
|
|
|
SDL_RWops *pubkey_rw = SDL_RWFromConstMem(pubkey, strlen(pubkey));
|
2016-06-23 21:09:57 +02:00
|
|
|
if (signature == nullptr || pubkey_rw == nullptr) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_VERIFICATIONFAILURE;
|
2016-06-23 21:09:57 +02:00
|
|
|
log_verbose("Signature verification failed, invalid data!");
|
2016-05-27 22:34:13 +02:00
|
|
|
} else {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.Key.LoadPublic(pubkey_rw);
|
2016-05-27 22:34:13 +02:00
|
|
|
SDL_RWclose(pubkey_rw);
|
2016-05-28 20:03:57 +02:00
|
|
|
bool verified = connection.Key.Verify(connection.Challenge.data(), connection.Challenge.size(), signature, sigsize);
|
|
|
|
const std::string hash = connection.Key.PublicKeyHash();
|
2016-05-27 22:34:13 +02:00
|
|
|
if (verified) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_VERIFIED;
|
2016-05-27 22:34:13 +02:00
|
|
|
log_verbose("Signature verification ok. Hash %s", hash.c_str());
|
|
|
|
} else {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_VERIFICATIONFAILURE;
|
2016-05-27 22:34:13 +02:00
|
|
|
log_verbose("Signature verification failed!");
|
|
|
|
}
|
|
|
|
if (gConfigNetwork.known_keys_only && _userManager.GetUserByHash(hash) == nullptr) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_UNKNOWN_KEY_DISALLOWED;
|
2016-05-27 22:34:13 +02:00
|
|
|
}
|
2016-05-26 16:11:50 +02:00
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
}
|
|
|
|
|
2016-05-27 23:00:31 +02:00
|
|
|
bool passwordless = false;
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.AuthStatus == NETWORK_AUTH_VERIFIED) {
|
|
|
|
const NetworkGroup * group = GetGroupByID(GetGroupIDByHash(connection.Key.PublicKeyHash()));
|
2016-05-28 19:29:56 +02:00
|
|
|
size_t actionIndex = NetworkActions::FindCommandByPermissionName("PERMISSION_PASSWORDLESS_LOGIN");
|
2016-05-27 23:00:31 +02:00
|
|
|
passwordless = group->CanPerformAction(actionIndex);
|
|
|
|
}
|
2016-01-30 22:28:51 +01:00
|
|
|
if (!gameversion || strcmp(gameversion, NETWORK_STREAM_ID) != 0) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_BADVERSION;
|
2015-07-16 19:32:43 +02:00
|
|
|
} else
|
|
|
|
if (!name) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_BADNAME;
|
2015-07-16 19:32:43 +02:00
|
|
|
} else
|
2016-05-24 17:16:02 +02:00
|
|
|
if (!passwordless) {
|
|
|
|
if ((!password || strlen(password) == 0) && Network::password.size() > 0) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_REQUIREPASSWORD;
|
2016-05-24 17:16:02 +02:00
|
|
|
} else
|
|
|
|
if (password && Network::password != password) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_BADPASSWORD;
|
2016-05-24 17:16:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
if (gConfigNetwork.maxplayers <= player_list.size()) {
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.AuthStatus = NETWORK_AUTH_FULL;
|
2016-05-19 10:23:42 +02:00
|
|
|
} else
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.AuthStatus == NETWORK_AUTH_VERIFIED) {
|
|
|
|
connection.AuthStatus = NETWORK_AUTH_OK;
|
|
|
|
const std::string hash = connection.Key.PublicKeyHash();
|
2016-05-19 10:23:42 +02:00
|
|
|
Server_Client_Joined(name, hash, connection);
|
2016-05-22 11:29:22 +02:00
|
|
|
} else
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.AuthStatus != NETWORK_AUTH_REQUIREPASSWORD) {
|
|
|
|
log_error("Unknown failure (%d) while authenticating client", connection.AuthStatus);
|
2015-07-16 19:32:43 +02:00
|
|
|
}
|
2015-11-02 04:12:14 +01:00
|
|
|
Server_Send_AUTH(connection);
|
2015-07-15 08:23:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_MAP(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
|
|
|
uint32 size, offset;
|
|
|
|
packet >> size >> offset;
|
2016-02-02 22:11:19 +01:00
|
|
|
int chunksize = packet.size - packet.read;
|
|
|
|
if (chunksize <= 0) {
|
2016-01-22 07:32:40 +01:00
|
|
|
return;
|
2016-02-02 22:11:19 +01:00
|
|
|
}
|
2016-04-20 08:25:31 +02:00
|
|
|
if (size > chunk_buffer.size()) {
|
|
|
|
chunk_buffer.resize(size);
|
2016-02-02 22:11:19 +01:00
|
|
|
}
|
2016-02-18 17:43:47 +01:00
|
|
|
char str_downloading_map[256];
|
2016-04-17 22:27:23 +02:00
|
|
|
unsigned int downloading_map_args[2] = {(offset + chunksize) / 1024, size / 1024};
|
2016-02-18 17:43:47 +01:00
|
|
|
format_string(str_downloading_map, STR_MULTIPLAYER_DOWNLOADING_MAP, downloading_map_args);
|
2016-03-23 00:27:49 +01:00
|
|
|
window_network_status_open(str_downloading_map, []() -> void {
|
|
|
|
gNetwork.Close();
|
|
|
|
});
|
2016-02-02 22:11:19 +01:00
|
|
|
memcpy(&chunk_buffer[offset], (void*)packet.Read(chunksize), chunksize);
|
|
|
|
if (offset + chunksize == size) {
|
|
|
|
window_network_status_close();
|
|
|
|
bool has_to_free = false;
|
|
|
|
unsigned char *data = &chunk_buffer[0];
|
|
|
|
size_t data_size = size;
|
|
|
|
// zlib-compressed
|
|
|
|
if (strcmp("open2_sv6_zlib", (char *)&chunk_buffer[0]) == 0)
|
|
|
|
{
|
2016-02-02 22:37:26 +01:00
|
|
|
log_verbose("Received zlib-compressed sv6 map");
|
2016-02-02 22:11:19 +01:00
|
|
|
has_to_free = true;
|
|
|
|
size_t header_len = strlen("open2_sv6_zlib") + 1;
|
|
|
|
data = util_zlib_inflate(&chunk_buffer[header_len], size - header_len, &data_size);
|
|
|
|
if (data == NULL)
|
2016-01-20 11:22:35 +01:00
|
|
|
{
|
2016-02-02 22:11:19 +01:00
|
|
|
log_warning("Failed to decompress data sent from server.");
|
2016-06-09 19:37:12 +02:00
|
|
|
Close();
|
2016-02-02 22:11:19 +01:00
|
|
|
return;
|
2016-01-20 11:22:35 +01:00
|
|
|
}
|
2016-02-02 22:11:19 +01:00
|
|
|
} else {
|
2016-02-02 22:37:26 +01:00
|
|
|
log_verbose("Assuming received map is in plain sv6 format");
|
2016-02-02 22:11:19 +01:00
|
|
|
}
|
|
|
|
SDL_RWops* rw = SDL_RWFromMem(data, data_size);
|
|
|
|
if (game_load_network(rw)) {
|
|
|
|
game_load_init();
|
|
|
|
game_command_queue.clear();
|
2016-04-23 03:49:24 +02:00
|
|
|
server_tick = gCurrentTicks;
|
2016-02-02 22:11:19 +01:00
|
|
|
server_srand0_tick = 0;
|
|
|
|
// window_network_status_open("Loaded new map from network");
|
|
|
|
_desynchronised = false;
|
2016-02-26 10:22:14 +01:00
|
|
|
|
|
|
|
// Notify user he is now online and which shortcut key enables chat
|
|
|
|
network_chat_show_connected_message();
|
2016-02-02 22:11:19 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//Something went wrong, game is not loaded. Return to main screen.
|
|
|
|
game_do_command(0, GAME_COMMAND_FLAG_APPLY, 0, 0, GAME_COMMAND_LOAD_OR_QUIT, 1, 0);
|
|
|
|
}
|
|
|
|
SDL_RWclose(rw);
|
|
|
|
if (has_to_free)
|
|
|
|
{
|
|
|
|
free(data);
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_CHAT(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
2015-11-01 08:50:44 +01:00
|
|
|
const char* text = packet.ReadString();
|
2015-07-19 01:57:42 +02:00
|
|
|
if (text) {
|
|
|
|
chat_history_add(text);
|
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Server_Handle_CHAT(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 08:23:04 +02:00
|
|
|
{
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.Player) {
|
|
|
|
NetworkGroup* group = GetGroupByID(connection.Player->group);
|
2016-01-23 19:34:05 +01:00
|
|
|
if (!group || (group && !group->CanPerformCommand(-1))) {
|
|
|
|
return;
|
2016-01-22 07:32:40 +01:00
|
|
|
}
|
|
|
|
}
|
2015-11-01 08:50:44 +01:00
|
|
|
const char* text = packet.ReadString();
|
2015-07-19 01:57:42 +02:00
|
|
|
if (text) {
|
2016-05-28 20:03:57 +02:00
|
|
|
const char* formatted = FormatChat(connection.Player, text);
|
2015-07-19 01:57:42 +02:00
|
|
|
chat_history_add(formatted);
|
|
|
|
Server_Send_CHAT(formatted);
|
|
|
|
}
|
2015-07-15 08:23:04 +02:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_GAMECMD(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
|
|
|
uint32 tick;
|
|
|
|
uint32 args[7];
|
2015-07-24 01:22:03 +02:00
|
|
|
uint8 playerid;
|
|
|
|
uint8 callback;
|
|
|
|
packet >> tick >> args[0] >> args[1] >> args[2] >> args[3] >> args[4] >> args[5] >> args[6] >> playerid >> callback;
|
2015-08-16 18:29:47 +02:00
|
|
|
|
2015-08-20 04:34:52 +02:00
|
|
|
GameCommand gc = GameCommand(tick, args, playerid, callback);
|
|
|
|
game_command_queue.insert(gc);
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Server_Handle_GAMECMD(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
2015-07-15 08:23:04 +02:00
|
|
|
uint32 tick;
|
|
|
|
uint32 args[7];
|
2015-07-24 01:22:03 +02:00
|
|
|
uint8 playerid;
|
|
|
|
uint8 callback;
|
2016-01-20 23:45:09 +01:00
|
|
|
|
2016-05-28 20:03:57 +02:00
|
|
|
if (!connection.Player) {
|
2016-01-22 07:32:40 +01:00
|
|
|
return;
|
2015-07-24 01:22:03 +02:00
|
|
|
}
|
2016-01-20 23:45:09 +01:00
|
|
|
|
2016-05-28 20:03:57 +02:00
|
|
|
playerid = connection.Player->id;
|
2016-01-20 23:45:09 +01:00
|
|
|
|
2015-07-24 01:22:03 +02:00
|
|
|
packet >> tick >> args[0] >> args[1] >> args[2] >> args[3] >> args[4] >> args[5] >> args[6] >> callback;
|
2015-11-08 15:32:22 +01:00
|
|
|
|
|
|
|
int commandCommand = args[4];
|
2015-11-12 10:55:47 +01:00
|
|
|
|
2016-03-24 23:59:16 +01:00
|
|
|
int ticks = SDL_GetTicks(); //tick count is different by time last_action_time is set, keep same value.
|
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
// Check if player's group permission allows command to run
|
2016-05-28 20:03:57 +02:00
|
|
|
NetworkGroup* group = GetGroupByID(connection.Player->group);
|
2016-01-23 19:34:05 +01:00
|
|
|
if (!group || (group && !group->CanPerformCommand(commandCommand))) {
|
2016-01-20 23:45:09 +01:00
|
|
|
Server_Send_SHOWERROR(connection, STR_CANT_DO_THIS, STR_PERMISSION_DENIED);
|
2016-01-22 07:32:40 +01:00
|
|
|
return;
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
2016-05-26 09:49:19 +02:00
|
|
|
// In case someone modifies the code / memory to enable cluster build,
|
2016-03-24 23:59:16 +01:00
|
|
|
// require a small delay in between placing scenery to provide some security, as
|
|
|
|
// cluster mode is a for loop that runs the place_scenery code multiple times.
|
|
|
|
if (commandCommand == GAME_COMMAND_PLACE_SCENERY) {
|
2016-05-28 20:03:57 +02:00
|
|
|
if ((ticks - connection.Player->last_action_time) < 20) {
|
2016-03-24 23:59:16 +01:00
|
|
|
if (!(group->CanPerformCommand(-2))) {
|
|
|
|
Server_Send_SHOWERROR(connection, STR_CANT_DO_THIS, STR_CANT_DO_THIS);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-11-08 15:32:22 +01:00
|
|
|
// Don't let clients send pause or quit
|
2016-01-20 23:45:09 +01:00
|
|
|
if (commandCommand == GAME_COMMAND_TOGGLE_PAUSE ||
|
|
|
|
commandCommand == GAME_COMMAND_LOAD_OR_QUIT
|
2015-11-08 15:32:22 +01:00
|
|
|
) {
|
2016-01-22 07:32:40 +01:00
|
|
|
return;
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
// Set this to reference inside of game command functions
|
|
|
|
game_command_playerid = playerid;
|
2016-01-20 23:45:09 +01:00
|
|
|
// Run game command, and if it is successful send to clients
|
|
|
|
money32 cost = game_do_command(args[0], args[1] | GAME_COMMAND_FLAG_NETWORKED, args[2], args[3], args[4], args[5], args[6]);
|
|
|
|
if (cost == MONEY32_UNDEFINED) {
|
2016-01-22 07:32:40 +01:00
|
|
|
return;
|
2015-11-08 15:32:22 +01:00
|
|
|
}
|
2016-01-23 20:32:02 +01:00
|
|
|
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.Player->last_action = NetworkActions::FindCommand(commandCommand);
|
|
|
|
connection.Player->last_action_time = SDL_GetTicks();
|
|
|
|
connection.Player->AddMoneySpent(cost);
|
2016-01-20 23:45:09 +01:00
|
|
|
Server_Send_GAMECMD(args[0], args[1], args[2], args[3], args[4], args[5], args[6], playerid, callback);
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_TICK(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
2015-07-30 16:34:17 +02:00
|
|
|
uint32 srand0;
|
2016-07-24 21:32:57 +02:00
|
|
|
uint32 flags;
|
|
|
|
// Note: older server version may not advertise flags at all.
|
|
|
|
// NetworkPacket will return 0, if trying to read past end of buffer,
|
|
|
|
// so flags == 0 is expected in such cases.
|
|
|
|
packet >> server_tick >> srand0 >> flags;
|
2015-07-30 16:34:17 +02:00
|
|
|
if (server_srand0_tick == 0) {
|
|
|
|
server_srand0 = srand0;
|
|
|
|
server_srand0_tick = server_tick;
|
2016-07-24 21:32:57 +02:00
|
|
|
server_sprite_hash[0] = '\0';
|
|
|
|
if (flags & NETWORK_TICK_FLAG_CHECKSUMS)
|
|
|
|
{
|
|
|
|
const char* text = packet.ReadString();
|
|
|
|
if (text != nullptr)
|
|
|
|
{
|
|
|
|
safe_strcpy(server_sprite_hash, text, sizeof(server_sprite_hash));
|
|
|
|
}
|
|
|
|
}
|
2015-07-30 16:34:17 +02:00
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_PLAYERLIST(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-16 19:32:43 +02:00
|
|
|
{
|
2016-01-22 07:32:40 +01:00
|
|
|
uint8 size;
|
2015-07-16 19:32:43 +02:00
|
|
|
packet >> size;
|
2016-01-20 23:45:09 +01:00
|
|
|
std::vector<uint8> ids;
|
2015-07-16 19:32:43 +02:00
|
|
|
for (unsigned int i = 0; i < size; i++) {
|
2016-01-22 04:32:51 +01:00
|
|
|
NetworkPlayer tempplayer;
|
|
|
|
tempplayer.Read(packet);
|
|
|
|
ids.push_back(tempplayer.id);
|
|
|
|
if (!GetPlayerByID(tempplayer.id)) {
|
2016-05-25 23:01:10 +02:00
|
|
|
NetworkPlayer* player = AddPlayer("", "");
|
2016-01-20 23:45:09 +01:00
|
|
|
if (player) {
|
2016-01-22 04:32:51 +01:00
|
|
|
*player = tempplayer;
|
2016-01-20 23:45:09 +01:00
|
|
|
if (player->flags & NETWORK_PLAYER_FLAG_ISSERVER) {
|
2016-05-28 20:03:57 +02:00
|
|
|
server_connection.Player = player;
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-01-20 23:45:09 +01:00
|
|
|
// Remove any players that are not in newly received list
|
|
|
|
auto it = player_list.begin();
|
|
|
|
while (it != player_list.end()) {
|
|
|
|
if (std::find(ids.begin(), ids.end(), (*it)->id) == ids.end()) {
|
|
|
|
it = player_list.erase(it);
|
|
|
|
} else {
|
|
|
|
it++;
|
|
|
|
}
|
|
|
|
}
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_PING(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-17 02:24:39 +02:00
|
|
|
{
|
|
|
|
Client_Send_PING();
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Server_Handle_PING(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-17 02:24:39 +02:00
|
|
|
{
|
2016-05-28 20:03:57 +02:00
|
|
|
int ping = SDL_GetTicks() - connection.PingTime;
|
2015-07-17 02:24:39 +02:00
|
|
|
if (ping < 0) {
|
|
|
|
ping = 0;
|
|
|
|
}
|
2016-05-28 20:03:57 +02:00
|
|
|
if (connection.Player) {
|
|
|
|
connection.Player->ping = ping;
|
|
|
|
window_invalidate_by_number(WC_PLAYER, connection.Player->id);
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_PINGLIST(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-17 02:24:39 +02:00
|
|
|
{
|
2016-01-22 07:32:40 +01:00
|
|
|
uint8 size;
|
2015-07-17 02:24:39 +02:00
|
|
|
packet >> size;
|
|
|
|
for (unsigned int i = 0; i < size; i++) {
|
|
|
|
uint8 id;
|
|
|
|
uint16 ping;
|
|
|
|
packet >> id >> ping;
|
|
|
|
NetworkPlayer* player = GetPlayerByID(id);
|
|
|
|
if (player) {
|
|
|
|
player->ping = ping;
|
2015-07-16 19:32:43 +02:00
|
|
|
}
|
|
|
|
}
|
2016-01-20 23:45:09 +01:00
|
|
|
window_invalidate_by_class(WC_PLAYER);
|
2015-07-16 19:32:43 +02:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_SETDISCONNECTMSG(NetworkConnection& connection, NetworkPacket& packet)
|
2015-11-01 08:50:44 +01:00
|
|
|
{
|
2015-11-04 00:31:09 +01:00
|
|
|
static std::string msg;
|
2015-11-01 08:50:44 +01:00
|
|
|
const char* disconnectmsg = packet.ReadString();
|
|
|
|
if (disconnectmsg) {
|
2015-11-04 00:31:09 +01:00
|
|
|
msg = disconnectmsg;
|
2016-05-28 20:03:57 +02:00
|
|
|
connection.SetLastDisconnectReason(msg.c_str());
|
2015-11-01 08:50:44 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Server_Handle_GAMEINFO(NetworkConnection& connection, NetworkPacket& packet)
|
2015-11-04 00:31:09 +01:00
|
|
|
{
|
|
|
|
Server_Send_GAMEINFO(connection);
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void Network::Client_Handle_SHOWERROR(NetworkConnection& connection, NetworkPacket& packet)
|
2016-01-20 23:45:09 +01:00
|
|
|
{
|
|
|
|
rct_string_id title, message;
|
|
|
|
packet >> title >> message;
|
|
|
|
window_error_open(title, message);
|
2016-01-22 07:32:40 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Client_Handle_GROUPLIST(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
group_list.clear();
|
|
|
|
uint8 size;
|
2016-01-24 02:57:56 +01:00
|
|
|
packet >> size >> default_group;
|
2016-01-22 07:32:40 +01:00
|
|
|
for (unsigned int i = 0; i < size; i++) {
|
|
|
|
NetworkGroup group;
|
|
|
|
group.Read(packet);
|
|
|
|
std::unique_ptr<NetworkGroup> newgroup(new NetworkGroup(group)); // change to make_unique in c++14
|
|
|
|
group_list.push_back(std::move(newgroup));
|
|
|
|
}
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
|
|
|
|
2016-02-27 14:12:04 +01:00
|
|
|
void Network::Client_Handle_EVENT(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
uint16 eventType;
|
|
|
|
packet >> eventType;
|
|
|
|
switch (eventType) {
|
|
|
|
case SERVER_EVENT_PLAYER_JOINED:
|
|
|
|
{
|
|
|
|
char text[256];
|
|
|
|
const char *playerName = packet.ReadString();
|
|
|
|
format_string(text, STR_MULTIPLAYER_PLAYER_HAS_JOINED_THE_GAME, &playerName);
|
|
|
|
chat_history_add(text);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SERVER_EVENT_PLAYER_DISCONNECTED:
|
|
|
|
{
|
|
|
|
char text[256];
|
|
|
|
const char *playerName = packet.ReadString();
|
|
|
|
const char *reason = packet.ReadString();
|
|
|
|
const char *args[] = { playerName, reason };
|
|
|
|
if (str_is_null_or_empty(reason)) {
|
|
|
|
format_string(text, STR_MULTIPLAYER_PLAYER_HAS_DISCONNECTED_NO_REASON, args);
|
|
|
|
} else {
|
|
|
|
format_string(text, STR_MULTIPLAYER_PLAYER_HAS_DISCONNECTED_WITH_REASON, args);
|
|
|
|
}
|
|
|
|
chat_history_add(text);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-30 23:25:43 +02:00
|
|
|
void Network::Client_Send_GAMEINFO()
|
|
|
|
{
|
|
|
|
log_verbose("requesting gameinfo");
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_GAMEINFO;
|
|
|
|
server_connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2016-07-13 00:46:51 +02:00
|
|
|
static std::string json_stdstring_value(const json_t * string)
|
2016-05-30 23:25:43 +02:00
|
|
|
{
|
|
|
|
const char * cstr = json_string_value(string);
|
|
|
|
return cstr == nullptr ? std::string() : std::string(cstr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Client_Handle_GAMEINFO(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
const char * jsonString = packet.ReadString();
|
|
|
|
|
|
|
|
json_error_t error;
|
|
|
|
json_t *root = json_loads(jsonString, 0, &error);
|
|
|
|
|
|
|
|
ServerName = json_stdstring_value(json_object_get(root, "name"));
|
|
|
|
ServerDescription = json_stdstring_value(json_object_get(root, "description"));
|
2016-08-14 06:15:45 +02:00
|
|
|
ServerGreeting = json_stdstring_value(json_object_get(root, "greeting"));
|
2016-05-30 23:25:43 +02:00
|
|
|
|
|
|
|
json_t *jsonProvider = json_object_get(root, "provider");
|
|
|
|
if (jsonProvider != nullptr) {
|
2016-05-31 20:24:07 +02:00
|
|
|
ServerProviderName = json_stdstring_value(json_object_get(jsonProvider, "name"));
|
|
|
|
ServerProviderEmail = json_stdstring_value(json_object_get(jsonProvider, "email"));
|
|
|
|
ServerProviderWebsite = json_stdstring_value(json_object_get(jsonProvider, "website"));
|
2016-05-30 23:25:43 +02:00
|
|
|
}
|
|
|
|
json_decref(root);
|
2016-08-14 06:15:45 +02:00
|
|
|
|
2016-08-15 19:08:23 +02:00
|
|
|
network_chat_show_server_greeting();
|
2016-05-30 23:25:43 +02:00
|
|
|
}
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
namespace Convert
|
|
|
|
{
|
|
|
|
uint16 HostToNetwork(uint16 value)
|
|
|
|
{
|
|
|
|
return htons(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
uint16 NetworkToHost(uint16 value)
|
|
|
|
{
|
|
|
|
return ntohs(value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
int network_init()
|
|
|
|
{
|
|
|
|
return gNetwork.Init();
|
|
|
|
}
|
|
|
|
|
|
|
|
void network_close()
|
|
|
|
{
|
|
|
|
gNetwork.Close();
|
|
|
|
}
|
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
void network_shutdown_client()
|
|
|
|
{
|
|
|
|
gNetwork.ShutdownClient();
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
int network_begin_client(const char *host, int port)
|
|
|
|
{
|
|
|
|
return gNetwork.BeginClient(host, port);
|
|
|
|
}
|
|
|
|
|
|
|
|
int network_begin_server(int port)
|
|
|
|
{
|
|
|
|
return gNetwork.BeginServer(port);
|
|
|
|
}
|
|
|
|
|
|
|
|
void network_update()
|
|
|
|
{
|
|
|
|
gNetwork.Update();
|
|
|
|
}
|
|
|
|
|
|
|
|
int network_get_mode()
|
|
|
|
{
|
|
|
|
return gNetwork.GetMode();
|
|
|
|
}
|
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
int network_get_status()
|
|
|
|
{
|
|
|
|
return gNetwork.GetStatus();
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
int network_get_authstatus()
|
|
|
|
{
|
|
|
|
return gNetwork.GetAuthStatus();
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
uint32 network_get_server_tick()
|
|
|
|
{
|
|
|
|
return gNetwork.GetServerTick();
|
|
|
|
}
|
|
|
|
|
2015-10-16 23:20:16 +02:00
|
|
|
uint8 network_get_current_player_id()
|
2015-07-24 01:22:03 +02:00
|
|
|
{
|
|
|
|
return gNetwork.GetPlayerID();
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
int network_get_num_players()
|
|
|
|
{
|
|
|
|
return gNetwork.player_list.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* network_get_player_name(unsigned int index)
|
|
|
|
{
|
2016-05-24 00:20:41 +02:00
|
|
|
return (const char*)gNetwork.player_list[index]->name.c_str();
|
2015-07-16 19:32:43 +02:00
|
|
|
}
|
|
|
|
|
2015-07-17 02:24:39 +02:00
|
|
|
uint32 network_get_player_flags(unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.player_list[index]->flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
int network_get_player_ping(unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.player_list[index]->ping;
|
|
|
|
}
|
|
|
|
|
2015-10-16 23:20:16 +02:00
|
|
|
int network_get_player_id(unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.player_list[index]->id;
|
|
|
|
}
|
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
money32 network_get_player_money_spent(unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.player_list[index]->money_spent;
|
|
|
|
}
|
|
|
|
|
|
|
|
void network_add_player_money_spent(unsigned int index, money32 cost)
|
|
|
|
{
|
|
|
|
gNetwork.player_list[index]->AddMoneySpent(cost);
|
|
|
|
}
|
|
|
|
|
2016-01-24 00:46:52 +01:00
|
|
|
int network_get_player_last_action(unsigned int index, int time)
|
2016-01-23 20:32:02 +01:00
|
|
|
{
|
2016-01-24 00:46:52 +01:00
|
|
|
if (time && SDL_TICKS_PASSED(SDL_GetTicks(), gNetwork.player_list[index]->last_action_time + time)) {
|
2016-01-23 20:32:02 +01:00
|
|
|
return -999;
|
|
|
|
}
|
|
|
|
return gNetwork.player_list[index]->last_action;
|
|
|
|
}
|
|
|
|
|
|
|
|
void network_set_player_last_action(unsigned int index, int command)
|
|
|
|
{
|
2016-05-28 19:29:56 +02:00
|
|
|
gNetwork.player_list[index]->last_action = NetworkActions::FindCommand(command);
|
2016-01-23 20:32:02 +01:00
|
|
|
gNetwork.player_list[index]->last_action_time = SDL_GetTicks();
|
|
|
|
}
|
|
|
|
|
2016-01-23 22:16:26 +01:00
|
|
|
rct_xyz16 network_get_player_last_action_coord(unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.player_list[index]->last_action_coord;
|
|
|
|
}
|
|
|
|
|
2016-02-02 01:04:39 +01:00
|
|
|
void network_set_player_last_action_coord(unsigned int index, rct_xyz16 coord)
|
2016-01-23 22:16:26 +01:00
|
|
|
{
|
2016-02-02 01:04:39 +01:00
|
|
|
if (index < gNetwork.player_list.size()) {
|
2016-01-25 05:00:31 +01:00
|
|
|
gNetwork.player_list[index]->last_action_coord = coord;
|
|
|
|
}
|
2016-01-23 22:16:26 +01:00
|
|
|
}
|
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
unsigned int network_get_player_commands_ran(unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.player_list[index]->commands_ran;
|
|
|
|
}
|
|
|
|
|
|
|
|
int network_get_player_index(uint8 id)
|
|
|
|
{
|
|
|
|
auto it = gNetwork.GetPlayerIteratorByID(id);
|
|
|
|
if(it == gNetwork.player_list.end()){
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return gNetwork.GetPlayerIteratorByID(id) - gNetwork.player_list.begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8 network_get_player_group(unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.player_list[index]->group;
|
|
|
|
}
|
|
|
|
|
|
|
|
void network_set_player_group(unsigned int index, unsigned int groupindex)
|
|
|
|
{
|
2016-05-28 20:03:57 +02:00
|
|
|
gNetwork.player_list[index]->group = gNetwork.group_list[groupindex]->Id;
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int network_get_group_index(uint8 id)
|
|
|
|
{
|
|
|
|
auto it = gNetwork.GetGroupIteratorByID(id);
|
|
|
|
if(it == gNetwork.group_list.end()){
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return gNetwork.GetGroupIteratorByID(id) - gNetwork.group_list.begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8 network_get_group_id(unsigned int index)
|
|
|
|
{
|
2016-05-28 20:03:57 +02:00
|
|
|
return gNetwork.group_list[index]->Id;
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int network_get_num_groups()
|
|
|
|
{
|
|
|
|
return gNetwork.group_list.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* network_get_group_name(unsigned int index)
|
|
|
|
{
|
2016-01-22 04:32:51 +01:00
|
|
|
return gNetwork.group_list[index]->GetName().c_str();
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
|
|
|
|
2016-02-26 10:22:14 +01:00
|
|
|
void network_chat_show_connected_message()
|
|
|
|
{
|
2016-07-14 14:07:49 +02:00
|
|
|
// TODO: How does this work? 2525 is '???'
|
|
|
|
char *templateString = (char*)language_get_string(STR_SHORTCUT_KEY_UNKNOWN);
|
2016-02-26 10:22:14 +01:00
|
|
|
keyboard_shortcut_format_string(templateString, gShortcutKeys[SHORTCUT_OPEN_CHAT_WINDOW]);
|
|
|
|
utf8 buffer[256];
|
|
|
|
NetworkPlayer server;
|
2016-05-24 00:20:41 +02:00
|
|
|
server.name = "Server";
|
2016-02-26 10:22:14 +01:00
|
|
|
format_string(buffer, STR_MULTIPLAYER_CONNECTED_CHAT_HINT, &templateString);
|
|
|
|
const char *formatted = Network::FormatChat(&server, buffer);
|
|
|
|
chat_history_add(formatted);
|
|
|
|
}
|
|
|
|
|
2016-08-15 19:08:23 +02:00
|
|
|
// Display server greeting if one exists
|
|
|
|
void network_chat_show_server_greeting()
|
|
|
|
{
|
|
|
|
const char* greeting = gConfigNetwork.server_greeting;
|
|
|
|
if (!str_is_null_or_empty(greeting)) {
|
|
|
|
static char greeting_formatted[256];
|
|
|
|
char* lineCh = greeting_formatted;
|
|
|
|
greeting_formatted[0] = 0;
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_OUTLINE);
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_GREEN);
|
|
|
|
char* ptrtext = lineCh;
|
|
|
|
safe_strcpy(lineCh, greeting, 240);
|
|
|
|
utf8_remove_format_codes((utf8*)ptrtext, true);
|
|
|
|
chat_history_add(greeting_formatted);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
void game_command_set_player_group(int* eax, int* ebx, int* ecx, int* edx, int* esi, int* edi, int* ebp)
|
|
|
|
{
|
|
|
|
uint8 playerid = (uint8)*ecx;
|
|
|
|
uint8 groupid = (uint8)*edx;
|
|
|
|
NetworkPlayer* player = gNetwork.GetPlayerByID(playerid);
|
2016-01-23 19:34:05 +01:00
|
|
|
NetworkGroup* fromgroup = gNetwork.GetGroupByID(game_command_playerid);
|
2016-01-20 23:45:09 +01:00
|
|
|
if (!player) {
|
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!gNetwork.GetGroupByID(groupid)) {
|
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (player->flags & NETWORK_PLAYER_FLAG_ISSERVER) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_CANT_CHANGE_GROUP_THAT_THE_HOST_BELONGS_TO;
|
2016-01-20 23:45:09 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
2016-05-28 20:03:57 +02:00
|
|
|
if (groupid == 0 && fromgroup && fromgroup->Id != 0) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_CANT_SET_TO_THIS_GROUP;
|
2016-01-23 19:34:05 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
2016-01-20 23:45:09 +01:00
|
|
|
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
|
|
|
|
player->group = groupid;
|
2016-05-27 00:52:40 +02:00
|
|
|
|
|
|
|
if (network_get_mode() == NETWORK_MODE_SERVER) {
|
|
|
|
// Add or update saved user
|
|
|
|
NetworkUserManager *userManager = &gNetwork._userManager;
|
|
|
|
NetworkUser *networkUser = userManager->GetOrAddUser(player->keyhash);
|
|
|
|
networkUser->GroupId = groupid;
|
|
|
|
networkUser->Name = player->name;
|
|
|
|
userManager->Save();
|
|
|
|
}
|
|
|
|
|
2016-01-20 23:45:09 +01:00
|
|
|
window_invalidate_by_number(WC_PLAYER, playerid);
|
|
|
|
}
|
|
|
|
*ebx = 0;
|
|
|
|
}
|
|
|
|
|
2016-01-22 04:32:51 +01:00
|
|
|
void game_command_modify_groups(int *eax, int *ebx, int *ecx, int *edx, int *esi, int *edi, int *ebp)
|
|
|
|
{
|
|
|
|
uint8 action = (uint8)*eax;
|
|
|
|
uint8 groupid = (uint8)(*eax >> 8);
|
|
|
|
uint8 nameChunkIndex = (uint8)(*eax >> 16);
|
|
|
|
|
|
|
|
char oldName[128];
|
|
|
|
static char newName[128];
|
|
|
|
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case 0:{ // add group
|
2016-01-22 07:32:40 +01:00
|
|
|
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
|
|
|
|
NetworkGroup* newgroup = gNetwork.AddGroup();
|
|
|
|
if (!newgroup) {
|
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
}
|
|
|
|
}break;
|
|
|
|
case 1:{ // remove group
|
2016-01-22 07:32:40 +01:00
|
|
|
if (groupid == 0) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_THIS_GROUP_CANNOT_BE_MODIFIED;
|
2016-01-22 07:32:40 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (auto it = gNetwork.player_list.begin(); it != gNetwork.player_list.end(); it++) {
|
|
|
|
if((*it)->group == groupid) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_CANT_REMOVE_GROUP_THAT_PLAYERS_BELONG_TO;
|
2016-01-22 07:32:40 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
|
|
|
|
gNetwork.RemoveGroup(groupid);
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
}break;
|
2016-01-22 07:32:40 +01:00
|
|
|
case 2:{ // set permissions
|
|
|
|
int index = *ecx;
|
|
|
|
bool all = *edx & 1;
|
|
|
|
bool allvalue = (*edx >> 1) & 1;
|
2016-01-22 04:32:51 +01:00
|
|
|
if (groupid == 0) { // cant change admin group permissions
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_THIS_GROUP_CANNOT_BE_MODIFIED;
|
2016-01-22 04:32:51 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
2016-01-22 07:32:40 +01:00
|
|
|
NetworkGroup* mygroup = nullptr;
|
|
|
|
NetworkPlayer* player = gNetwork.GetPlayerByID(game_command_playerid);
|
2016-01-23 19:34:05 +01:00
|
|
|
if (player && !all) {
|
2016-01-22 07:32:40 +01:00
|
|
|
mygroup = gNetwork.GetGroupByID(player->group);
|
2016-01-23 19:34:05 +01:00
|
|
|
if (!mygroup || (mygroup && !mygroup->CanPerformAction(index))) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_CANT_MODIFY_PERMISSION_THAT_YOU_DO_NOT_HAVE_YOURSELF;
|
2016-01-23 19:34:05 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
2016-01-22 07:32:40 +01:00
|
|
|
}
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
|
|
|
|
NetworkGroup* group = gNetwork.GetGroupByID(groupid);
|
|
|
|
if (group) {
|
2016-01-22 07:32:40 +01:00
|
|
|
if (all) {
|
|
|
|
if (mygroup) {
|
|
|
|
if (allvalue) {
|
2016-05-28 20:03:57 +02:00
|
|
|
group->ActionsAllowed = mygroup->ActionsAllowed;
|
2016-01-22 07:32:40 +01:00
|
|
|
} else {
|
2016-05-28 20:03:57 +02:00
|
|
|
group->ActionsAllowed.fill(0x00);
|
2016-01-22 07:32:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
group->ToggleActionPermission(index);
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}break;
|
|
|
|
case 3:{ // set group name
|
|
|
|
size_t nameChunkOffset = nameChunkIndex - 1;
|
2016-01-22 23:57:50 +01:00
|
|
|
if (nameChunkIndex == 0)
|
2016-01-22 04:32:51 +01:00
|
|
|
nameChunkOffset = 2;
|
|
|
|
nameChunkOffset *= 12;
|
2016-01-22 07:32:40 +01:00
|
|
|
nameChunkOffset = (std::min)(nameChunkOffset, Util::CountOf(newName) - 12);
|
2016-01-22 04:32:51 +01:00
|
|
|
RCT2_GLOBAL(newName + nameChunkOffset + 0, uint32) = *edx;
|
|
|
|
RCT2_GLOBAL(newName + nameChunkOffset + 4, uint32) = *ebp;
|
|
|
|
RCT2_GLOBAL(newName + nameChunkOffset + 8, uint32) = *edi;
|
|
|
|
|
|
|
|
if (nameChunkIndex != 0) {
|
|
|
|
*ebx = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(oldName, newName) == 0) {
|
|
|
|
*ebx = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (newName[0] == 0) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_CANT_RENAME_GROUP;
|
|
|
|
gGameCommandErrorText = STR_INVALID_GROUP_NAME;
|
2016-01-22 04:32:51 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
|
|
|
|
NetworkGroup* group = gNetwork.GetGroupByID(groupid);
|
|
|
|
if (group) {
|
|
|
|
group->SetName(newName);
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
}
|
2016-01-22 07:32:40 +01:00
|
|
|
}break;
|
|
|
|
case 4:{ // set default group
|
2016-01-23 19:34:05 +01:00
|
|
|
if (groupid == 0) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_CANT_SET_TO_THIS_GROUP;
|
2016-01-23 19:34:05 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
|
2016-01-22 07:32:40 +01:00
|
|
|
gNetwork.SetDefaultGroup(groupid);
|
2016-01-22 04:32:51 +01:00
|
|
|
}
|
|
|
|
}break;
|
|
|
|
}
|
|
|
|
|
2016-01-24 02:05:53 +01:00
|
|
|
gNetwork.SaveGroups();
|
|
|
|
|
2016-01-22 04:32:51 +01:00
|
|
|
*ebx = 0;
|
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
void game_command_kick_player(int *eax, int *ebx, int *ecx, int *edx, int *esi, int *edi, int *ebp)
|
2016-01-20 23:45:09 +01:00
|
|
|
{
|
2016-01-22 07:32:40 +01:00
|
|
|
uint8 playerid = (uint8)*eax;
|
2016-01-23 21:27:33 +01:00
|
|
|
NetworkPlayer* player = gNetwork.GetPlayerByID(playerid);
|
|
|
|
if (player && player->flags & NETWORK_PLAYER_FLAG_ISSERVER) {
|
2016-04-15 18:54:46 +02:00
|
|
|
gGameCommandErrorTitle = STR_CANT_KICK_THE_HOST;
|
2016-01-23 21:27:33 +01:00
|
|
|
*ebx = MONEY32_UNDEFINED;
|
|
|
|
return;
|
|
|
|
}
|
2016-01-22 07:32:40 +01:00
|
|
|
if (*ebx & GAME_COMMAND_FLAG_APPLY) {
|
|
|
|
if (gNetwork.GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
gNetwork.KickPlayer(playerid);
|
2016-05-27 20:23:51 +02:00
|
|
|
|
|
|
|
NetworkUserManager * networkUserManager = &gNetwork._userManager;
|
|
|
|
networkUserManager->Load();
|
|
|
|
networkUserManager->RemoveUser(player->keyhash);
|
|
|
|
networkUserManager->Save();
|
2016-01-22 07:32:40 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
*ebx = 0;
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
|
|
|
|
2016-01-22 07:32:40 +01:00
|
|
|
uint8 network_get_default_group()
|
2016-01-20 23:45:09 +01:00
|
|
|
{
|
2016-01-22 07:32:40 +01:00
|
|
|
return gNetwork.GetDefaultGroup();
|
2016-01-20 23:45:09 +01:00
|
|
|
}
|
|
|
|
|
2016-01-22 04:32:51 +01:00
|
|
|
int network_get_num_actions()
|
|
|
|
{
|
2016-05-28 19:29:56 +02:00
|
|
|
return NetworkActions::Actions.size();
|
2016-01-22 04:32:51 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
rct_string_id network_get_action_name_string_id(unsigned int index)
|
|
|
|
{
|
2016-07-26 16:07:33 +02:00
|
|
|
if (index < NetworkActions::Actions.size())
|
|
|
|
{
|
|
|
|
return NetworkActions::Actions[index].Name;
|
|
|
|
} else {
|
|
|
|
return STR_NONE;
|
|
|
|
}
|
2016-01-22 04:32:51 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int network_can_perform_action(unsigned int groupindex, unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.group_list[groupindex]->CanPerformAction(index);
|
|
|
|
}
|
|
|
|
|
2016-03-24 23:59:16 +01:00
|
|
|
int network_can_perform_command(unsigned int groupindex, unsigned int index)
|
|
|
|
{
|
|
|
|
return gNetwork.group_list[groupindex]->CanPerformCommand(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
int network_get_current_player_group_index()
|
|
|
|
{
|
|
|
|
return network_get_group_index(gNetwork.GetPlayerByID(gNetwork.GetPlayerID())->group);
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
void network_send_map()
|
|
|
|
{
|
2015-07-15 08:23:04 +02:00
|
|
|
gNetwork.Server_Send_MAP();
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void network_send_chat(const char* text)
|
|
|
|
{
|
2015-07-15 08:23:04 +02:00
|
|
|
if (gNetwork.GetMode() == NETWORK_MODE_CLIENT) {
|
|
|
|
gNetwork.Client_Send_CHAT(text);
|
|
|
|
} else
|
|
|
|
if (gNetwork.GetMode() == NETWORK_MODE_SERVER) {
|
2015-07-24 01:22:03 +02:00
|
|
|
NetworkPlayer* player = gNetwork.GetPlayerByID(gNetwork.GetPlayerID());
|
2015-07-19 01:57:42 +02:00
|
|
|
const char* formatted = gNetwork.FormatChat(player, text);
|
|
|
|
chat_history_add(formatted);
|
|
|
|
gNetwork.Server_Send_CHAT(formatted);
|
2015-07-15 08:23:04 +02:00
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
2015-07-24 01:22:03 +02:00
|
|
|
void network_send_gamecmd(uint32 eax, uint32 ebx, uint32 ecx, uint32 edx, uint32 esi, uint32 edi, uint32 ebp, uint8 callback)
|
2015-07-10 21:53:41 +02:00
|
|
|
{
|
2015-08-16 00:19:15 +02:00
|
|
|
switch (gNetwork.GetMode()) {
|
|
|
|
case NETWORK_MODE_SERVER:
|
2015-07-24 01:22:03 +02:00
|
|
|
gNetwork.Server_Send_GAMECMD(eax, ebx, ecx, edx, esi, edi, ebp, gNetwork.GetPlayerID(), callback);
|
2015-08-16 00:19:15 +02:00
|
|
|
break;
|
|
|
|
case NETWORK_MODE_CLIENT:
|
|
|
|
gNetwork.Client_Send_GAMECMD(eax, ebx, ecx, edx, esi, edi, ebp, callback);
|
|
|
|
break;
|
2015-07-15 08:23:04 +02:00
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
2015-11-02 04:12:14 +01:00
|
|
|
void network_send_password(const char* password)
|
|
|
|
{
|
2016-05-25 21:46:59 +02:00
|
|
|
utf8 keyPath[MAX_PATH];
|
|
|
|
network_get_private_key_path(keyPath, sizeof(keyPath), gConfigNetwork.player_name);
|
2016-05-21 19:26:53 +02:00
|
|
|
if (!platform_file_exists(keyPath)) {
|
|
|
|
log_error("Private key %s missing! Restart the game to generate it.", keyPath);
|
|
|
|
return;
|
|
|
|
}
|
2016-05-19 10:23:42 +02:00
|
|
|
SDL_RWops *privkey = SDL_RWFromFile(keyPath, "rb");
|
|
|
|
gNetwork.key.LoadPrivate(privkey);
|
|
|
|
const std::string pubkey = gNetwork.key.PublicKeyString();
|
2016-05-21 00:05:11 +02:00
|
|
|
size_t sigsize;
|
2016-05-19 10:23:42 +02:00
|
|
|
char *signature;
|
2016-06-20 14:46:27 +02:00
|
|
|
gNetwork.key.Sign(gNetwork.challenge.data(), gNetwork.challenge.size(), &signature, &sigsize);
|
2016-05-19 10:23:42 +02:00
|
|
|
// 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);
|
|
|
|
delete [] signature;
|
2015-11-02 04:12:14 +01:00
|
|
|
}
|
|
|
|
|
2015-11-02 01:28:53 +01:00
|
|
|
void network_set_password(const char* password)
|
2015-10-16 23:20:16 +02:00
|
|
|
{
|
2015-11-02 01:28:53 +01:00
|
|
|
gNetwork.SetPassword(password);
|
2015-10-16 23:20:16 +02:00
|
|
|
}
|
|
|
|
|
2016-05-30 15:24:06 +02:00
|
|
|
void network_append_chat_log(const utf8 *text)
|
|
|
|
{
|
|
|
|
gNetwork.AppendChatLog(text);
|
|
|
|
}
|
|
|
|
|
2016-05-25 21:46:59 +02:00
|
|
|
static void network_get_keys_directory(utf8 *buffer, size_t bufferSize)
|
|
|
|
{
|
|
|
|
platform_get_user_directory(buffer, "keys");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void network_get_private_key_path(utf8 *buffer, size_t bufferSize, const utf8 * playerName)
|
|
|
|
{
|
|
|
|
network_get_keys_directory(buffer, bufferSize);
|
|
|
|
Path::Append(buffer, bufferSize, playerName);
|
|
|
|
String::Append(buffer, bufferSize, ".privkey");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void network_get_public_key_path(utf8 *buffer, size_t bufferSize, const utf8 * playerName, const utf8 * hash)
|
|
|
|
{
|
|
|
|
network_get_keys_directory(buffer, bufferSize);
|
|
|
|
Path::Append(buffer, bufferSize, playerName);
|
|
|
|
String::Append(buffer, bufferSize, "-");
|
|
|
|
String::Append(buffer, bufferSize, hash);
|
|
|
|
String::Append(buffer, bufferSize, ".pubkey");
|
|
|
|
}
|
|
|
|
|
2016-05-25 22:03:18 +02:00
|
|
|
static void network_get_keymap_path(utf8 *buffer, size_t bufferSize)
|
|
|
|
{
|
|
|
|
platform_get_user_directory(buffer, NULL);
|
|
|
|
Path::Append(buffer, bufferSize, "keymappings.json");
|
|
|
|
}
|
|
|
|
|
2016-05-30 23:25:43 +02:00
|
|
|
const utf8 * network_get_server_name() { return gNetwork.ServerName.c_str(); }
|
|
|
|
const utf8 * network_get_server_description() { return gNetwork.ServerDescription.c_str(); }
|
2016-08-14 06:15:45 +02:00
|
|
|
const utf8 * network_get_server_greeting() { return gNetwork.ServerGreeting.c_str(); }
|
2016-05-30 23:25:43 +02:00
|
|
|
const utf8 * network_get_server_provider_name() { return gNetwork.ServerProviderName.c_str(); }
|
|
|
|
const utf8 * network_get_server_provider_email() { return gNetwork.ServerProviderEmail.c_str(); }
|
|
|
|
const utf8 * network_get_server_provider_website() { return gNetwork.ServerProviderWebsite.c_str(); }
|
|
|
|
|
2015-08-18 09:30:55 +02:00
|
|
|
#else
|
|
|
|
int network_get_mode() { return NETWORK_MODE_NONE; }
|
2015-10-27 04:43:33 +01:00
|
|
|
int network_get_status() { return NETWORK_STATUS_NONE; }
|
2015-11-04 00:31:09 +01:00
|
|
|
int network_get_authstatus() { return NETWORK_AUTH_NONE; }
|
2016-04-23 03:49:24 +02:00
|
|
|
uint32 network_get_server_tick() { return gCurrentTicks; }
|
2015-08-18 09:30:55 +02:00
|
|
|
void network_send_gamecmd(uint32 eax, uint32 ebx, uint32 ecx, uint32 edx, uint32 esi, uint32 edi, uint32 ebp, uint8 callback) {}
|
|
|
|
void network_send_map() {}
|
|
|
|
void network_update() {}
|
|
|
|
int network_begin_client(const char *host, int port) { return 1; }
|
|
|
|
int network_begin_server(int port) { return 1; }
|
|
|
|
int network_get_num_players() { return 1; }
|
|
|
|
const char* network_get_player_name(unsigned int index) { return "local (OpenRCT2 compiled without MP)"; }
|
|
|
|
uint32 network_get_player_flags(unsigned int index) { return 0; }
|
|
|
|
int network_get_player_ping(unsigned int index) { return 0; }
|
2015-10-16 23:20:16 +02:00
|
|
|
int network_get_player_id(unsigned int index) { return 0; }
|
2016-01-20 23:45:09 +01:00
|
|
|
money32 network_get_player_money_spent(unsigned int index) { return MONEY(0, 0); }
|
|
|
|
void network_add_player_money_spent(unsigned int index, money32 cost) { }
|
2016-01-24 00:46:52 +01:00
|
|
|
int network_get_player_last_action(unsigned int index, int time) { return -999; }
|
2016-01-23 20:32:02 +01:00
|
|
|
void network_set_player_last_action(unsigned int index, int command) { }
|
2016-01-23 22:38:53 +01:00
|
|
|
rct_xyz16 network_get_player_last_action_coord(unsigned int index) { return {0, 0, 0}; }
|
2016-02-02 01:04:39 +01:00
|
|
|
void network_set_player_last_action_coord(unsigned int index, rct_xyz16 coord) { }
|
2016-01-20 23:45:09 +01:00
|
|
|
unsigned int network_get_player_commands_ran(unsigned int index) { return 0; }
|
2016-01-23 20:32:02 +01:00
|
|
|
int network_get_player_index(uint8 id) { return -1; }
|
2016-01-20 23:45:09 +01:00
|
|
|
uint8 network_get_player_group(unsigned int index) { return 0; }
|
|
|
|
void network_set_player_group(unsigned int index, unsigned int groupindex) { }
|
|
|
|
int network_get_group_index(uint8 id) { return -1; }
|
|
|
|
uint8 network_get_group_id(unsigned int index) { return 0; }
|
|
|
|
int network_get_num_groups() { return 0; }
|
|
|
|
const char* network_get_group_name(unsigned int index) { return ""; };
|
|
|
|
void game_command_set_player_group(int* eax, int* ebx, int* ecx, int* edx, int* esi, int* edi, int* ebp) { }
|
2016-01-22 07:32:40 +01:00
|
|
|
void game_command_modify_groups(int* eax, int* ebx, int* ecx, int* edx, int* esi, int* edi, int* ebp) { }
|
|
|
|
void game_command_kick_player(int* eax, int* ebx, int* ecx, int* edx, int* esi, int* edi, int* ebp) { }
|
2016-01-20 23:45:09 +01:00
|
|
|
uint8 network_get_default_group() { return 0; }
|
2016-01-22 04:32:51 +01:00
|
|
|
int network_get_num_actions() { return 0; }
|
|
|
|
rct_string_id network_get_action_name_string_id(unsigned int index) { return -1; }
|
|
|
|
int network_can_perform_action(unsigned int groupindex, unsigned int index) { return 0; }
|
2016-03-24 23:59:16 +01:00
|
|
|
int network_can_perform_command(unsigned int groupindex, unsigned int index) { return 0; }
|
2015-08-18 09:30:55 +02:00
|
|
|
void network_send_chat(const char* text) {}
|
2015-11-04 00:31:09 +01:00
|
|
|
void network_send_password(const char* password) {}
|
2015-08-18 09:30:55 +02:00
|
|
|
void network_close() {}
|
2015-11-04 00:31:09 +01:00
|
|
|
void network_shutdown_client() {}
|
2015-11-02 01:28:53 +01:00
|
|
|
void network_set_password(const char* password) {}
|
2015-10-18 13:02:31 +02:00
|
|
|
uint8 network_get_current_player_id() { return 0; }
|
2016-03-24 23:59:16 +01:00
|
|
|
int network_get_current_player_group_index() { return 0; }
|
2016-05-30 15:24:06 +02:00
|
|
|
void network_append_chat_log(const utf8 *text) { }
|
2016-05-30 23:25:43 +02:00
|
|
|
const utf8 * network_get_server_name() { return nullptr; }
|
|
|
|
const utf8 * network_get_server_description() { return nullptr; }
|
2016-08-14 06:15:45 +02:00
|
|
|
const utf8 * network_get_server_greeting() { return nullptr; }
|
2016-05-30 23:25:43 +02:00
|
|
|
const utf8 * network_get_server_provider_name() { return nullptr; }
|
|
|
|
const utf8 * network_get_server_provider_email() { return nullptr; }
|
|
|
|
const utf8 * network_get_server_provider_website() { return nullptr; }
|
2015-08-18 09:30:55 +02:00
|
|
|
#endif /* DISABLE_NETWORK */
|