2015-02-12 03:01:02 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* Copyright (c) 2014 Ted John
|
|
|
|
* OpenRCT2, an open source clone of Roller Coaster Tycoon 2.
|
|
|
|
*
|
|
|
|
* This file is part of OpenRCT2.
|
|
|
|
*
|
|
|
|
* 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.
|
2015-10-20 20:16:30 +02:00
|
|
|
|
2015-02-12 03:01:02 +01:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2015-10-20 20:16:30 +02:00
|
|
|
|
2015-02-12 03:01:02 +01:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2015-08-04 01:08:42 +02:00
|
|
|
extern "C" {
|
|
|
|
#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-07-07 16:09:21 +02:00
|
|
|
#include <math.h>
|
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>
|
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"
|
2015-02-12 17:23:49 +01:00
|
|
|
#include "../localisation/date.h"
|
|
|
|
#include "../localisation/localisation.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"
|
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-07-10 21:53:41 +02:00
|
|
|
enum {
|
2015-11-01 08:50:44 +01:00
|
|
|
NETWORK_READPACKET_SUCCESS,
|
|
|
|
NETWORK_READPACKET_NO_DATA,
|
|
|
|
NETWORK_READPACKET_MORE_DATA,
|
|
|
|
NETWORK_READPACKET_DISCONNECTED
|
2015-07-10 21:53:41 +02:00
|
|
|
};
|
2015-02-12 03:01:02 +01:00
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
enum {
|
|
|
|
NETWORK_COMMAND_AUTH,
|
|
|
|
NETWORK_COMMAND_MAP,
|
|
|
|
NETWORK_COMMAND_CHAT,
|
|
|
|
NETWORK_COMMAND_GAMECMD,
|
|
|
|
NETWORK_COMMAND_TICK,
|
2015-07-16 19:32:43 +02:00
|
|
|
NETWORK_COMMAND_PLAYERLIST,
|
2015-07-17 02:24:39 +02:00
|
|
|
NETWORK_COMMAND_PING,
|
|
|
|
NETWORK_COMMAND_PINGLIST,
|
2015-11-01 08:50:44 +01:00
|
|
|
NETWORK_COMMAND_SETDISCONNECTMSG,
|
2015-11-04 00:31:09 +01:00
|
|
|
NETWORK_COMMAND_GAMEINFO,
|
2015-11-02 01:28:53 +01:00
|
|
|
NETWORK_COMMAND_MAX,
|
|
|
|
NETWORK_COMMAND_INVALID = -1
|
2015-07-10 21:53:41 +02:00
|
|
|
};
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2015-08-16 00:19:15 +02:00
|
|
|
const char *NetworkCommandNames[] = {
|
|
|
|
"NETWORK_COMMAND_AUTH",
|
|
|
|
"NETWORK_COMMAND_MAP",
|
|
|
|
"NETWORK_COMMAND_CHAT",
|
|
|
|
"NETWORK_COMMAND_GAMECMD",
|
|
|
|
"NETWORK_COMMAND_TICK",
|
|
|
|
"NETWORK_COMMAND_PLAYERLIST",
|
|
|
|
"NETWORK_COMMAND_PING",
|
|
|
|
"NETWORK_COMMAND_PINGLIST",
|
|
|
|
};
|
|
|
|
|
2015-07-07 16:09:21 +02:00
|
|
|
NetworkPacket::NetworkPacket()
|
|
|
|
{
|
2015-07-15 06:40:22 +02:00
|
|
|
transferred = 0;
|
2015-07-07 16:09:21 +02:00
|
|
|
read = 0;
|
|
|
|
size = 0;
|
|
|
|
data = std::make_shared<std::vector<uint8>>();
|
|
|
|
}
|
|
|
|
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> NetworkPacket::Allocate()
|
2015-07-08 03:21:05 +02:00
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
return std::unique_ptr<NetworkPacket>(new NetworkPacket); // change to make_unique in c++14
|
2015-07-08 03:21:05 +02:00
|
|
|
}
|
|
|
|
|
2015-07-19 01:57:42 +02:00
|
|
|
std::unique_ptr<NetworkPacket> NetworkPacket::Duplicate(NetworkPacket& packet)
|
2015-07-08 03:21:05 +02:00
|
|
|
{
|
2015-07-19 01:57:42 +02:00
|
|
|
return std::unique_ptr<NetworkPacket>(new NetworkPacket(packet)); // change to make_unique in c++14
|
2015-07-08 03:21:05 +02:00
|
|
|
}
|
|
|
|
|
2015-07-07 16:09:21 +02:00
|
|
|
uint8* NetworkPacket::GetData()
|
|
|
|
{
|
|
|
|
return &(*data)[0];
|
|
|
|
}
|
|
|
|
|
2015-11-02 01:28:53 +01:00
|
|
|
uint32 NetworkPacket::GetCommand()
|
|
|
|
{
|
|
|
|
if (data->size() >= sizeof(uint32)) {
|
|
|
|
return ByteSwapBE(*(uint32*)(&(*data)[0]));
|
|
|
|
} else {
|
|
|
|
return NETWORK_COMMAND_INVALID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
void NetworkPacket::Write(uint8* bytes, unsigned int size)
|
|
|
|
{
|
|
|
|
data->insert(data->end(), bytes, bytes + size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void NetworkPacket::WriteString(const char* string)
|
|
|
|
{
|
|
|
|
Write((uint8*)string, strlen(string) + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
const uint8* NetworkPacket::Read(unsigned int size)
|
|
|
|
{
|
|
|
|
if (read + size > NetworkPacket::size) {
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
uint8* data = &GetData()[read];
|
|
|
|
read += size;
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* NetworkPacket::ReadString()
|
|
|
|
{
|
|
|
|
char* str = (char*)&GetData()[read];
|
|
|
|
char* strend = str;
|
|
|
|
while (read < size && *strend != 0) {
|
|
|
|
read++;
|
|
|
|
strend++;
|
|
|
|
}
|
|
|
|
if (*strend != 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
2015-07-16 19:32:43 +02:00
|
|
|
read++;
|
2015-07-15 08:23:04 +02:00
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2015-07-09 04:19:12 +02:00
|
|
|
void NetworkPacket::Clear()
|
|
|
|
{
|
2015-07-15 06:40:22 +02:00
|
|
|
transferred = 0;
|
2015-07-09 04:19:12 +02:00
|
|
|
read = 0;
|
|
|
|
data->clear();
|
|
|
|
}
|
|
|
|
|
2015-11-02 01:28:53 +01:00
|
|
|
bool NetworkPacket::CommandRequiresAuth()
|
|
|
|
{
|
|
|
|
switch (GetCommand()) {
|
|
|
|
case NETWORK_COMMAND_PING:
|
|
|
|
case NETWORK_COMMAND_AUTH:
|
2015-11-04 00:31:09 +01:00
|
|
|
case NETWORK_COMMAND_GAMEINFO:
|
2015-11-02 01:28:53 +01:00
|
|
|
return false;
|
|
|
|
default:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
NetworkPlayer::NetworkPlayer(const char* name)
|
|
|
|
{
|
2015-10-30 15:18:29 +01:00
|
|
|
safe_strncpy((char*)NetworkPlayer::name, name, sizeof(NetworkPlayer::name));
|
2015-07-16 19:32:43 +02:00
|
|
|
NetworkPlayer::name[sizeof(NetworkPlayer::name) - 1] = 0;
|
|
|
|
ping = 0;
|
2015-07-17 02:24:39 +02:00
|
|
|
flags = 0;
|
2015-07-16 19:32:43 +02:00
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
NetworkConnection::NetworkConnection()
|
|
|
|
{
|
|
|
|
authstatus = NETWORK_AUTH_NONE;
|
2015-07-16 19:32:43 +02:00
|
|
|
player = 0;
|
2015-10-27 04:43:33 +01:00
|
|
|
socket = INVALID_SOCKET;
|
2015-11-01 08:50:44 +01:00
|
|
|
ResetLastPacketTime();
|
|
|
|
last_disconnect_reason = NULL;
|
2015-10-27 04:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
NetworkConnection::~NetworkConnection()
|
|
|
|
{
|
|
|
|
if (socket != INVALID_SOCKET) {
|
|
|
|
closesocket(socket);
|
|
|
|
}
|
2015-07-15 08:23:04 +02:00
|
|
|
}
|
|
|
|
|
2015-07-07 16:09:21 +02:00
|
|
|
int NetworkConnection::ReadPacket()
|
|
|
|
{
|
2015-07-15 06:40:22 +02:00
|
|
|
if (inboundpacket.transferred < sizeof(inboundpacket.size)) {
|
2015-07-07 16:09:21 +02:00
|
|
|
// read packet size
|
2015-07-15 06:40:22 +02:00
|
|
|
int readBytes = recv(socket, &((char*)&inboundpacket.size)[inboundpacket.transferred], sizeof(inboundpacket.size) - inboundpacket.transferred, 0);
|
2015-07-07 16:09:21 +02:00
|
|
|
if (readBytes == SOCKET_ERROR || readBytes == 0) {
|
2015-09-24 19:39:15 +02:00
|
|
|
if (LAST_SOCKET_ERROR() != EWOULDBLOCK && LAST_SOCKET_ERROR() != EAGAIN) {
|
2015-11-01 08:50:44 +01:00
|
|
|
return NETWORK_READPACKET_DISCONNECTED;
|
2015-07-07 16:09:21 +02:00
|
|
|
} else {
|
2015-11-01 08:50:44 +01:00
|
|
|
return NETWORK_READPACKET_NO_DATA;
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
inboundpacket.transferred += readBytes;
|
|
|
|
if (inboundpacket.transferred == sizeof(inboundpacket.size)) {
|
2015-07-07 16:09:21 +02:00
|
|
|
inboundpacket.size = ntohs(inboundpacket.size);
|
2015-09-03 04:40:03 +02:00
|
|
|
if(inboundpacket.size == 0){ // Can't have a size 0 packet
|
2015-11-01 08:50:44 +01:00
|
|
|
return NETWORK_READPACKET_DISCONNECTED;
|
2015-09-03 04:40:03 +02:00
|
|
|
}
|
2015-07-07 16:09:21 +02:00
|
|
|
inboundpacket.data->resize(inboundpacket.size);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// read packet data
|
|
|
|
if (inboundpacket.data->capacity() > 0) {
|
2015-07-15 06:40:22 +02:00
|
|
|
int readBytes = recv(socket, (char*)&inboundpacket.GetData()[inboundpacket.transferred - sizeof(inboundpacket.size)], sizeof(inboundpacket.size) + inboundpacket.size - inboundpacket.transferred, 0);
|
2015-07-07 16:09:21 +02:00
|
|
|
if (readBytes == SOCKET_ERROR || readBytes == 0) {
|
2015-09-24 19:39:15 +02:00
|
|
|
if (LAST_SOCKET_ERROR() != EWOULDBLOCK && LAST_SOCKET_ERROR() != EAGAIN) {
|
2015-11-01 08:50:44 +01:00
|
|
|
return NETWORK_READPACKET_DISCONNECTED;
|
2015-07-07 16:09:21 +02:00
|
|
|
} else {
|
2015-11-01 08:50:44 +01:00
|
|
|
return NETWORK_READPACKET_NO_DATA;
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
inboundpacket.transferred += readBytes;
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
if (inboundpacket.transferred == sizeof(inboundpacket.size) + inboundpacket.size) {
|
2015-11-01 08:50:44 +01:00
|
|
|
last_packet_time = SDL_GetTicks();
|
|
|
|
return NETWORK_READPACKET_SUCCESS;
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
}
|
2015-11-01 08:50:44 +01:00
|
|
|
return NETWORK_READPACKET_MORE_DATA;
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
|
2015-09-03 04:40:03 +02:00
|
|
|
bool NetworkConnection::SendPacket(NetworkPacket& packet)
|
2015-07-07 16:09:21 +02:00
|
|
|
{
|
2015-09-03 04:40:03 +02:00
|
|
|
uint16 sizen = htons(packet.size);
|
|
|
|
std::vector<uint8> tosend;
|
2015-09-24 19:39:15 +02:00
|
|
|
tosend.reserve(sizeof(sizen) + packet.size);
|
2015-09-03 04:40:03 +02:00
|
|
|
tosend.insert(tosend.end(), (uint8*)&sizen, (uint8*)&sizen + sizeof(sizen));
|
|
|
|
tosend.insert(tosend.end(), packet.data->begin(), packet.data->end());
|
2015-07-07 16:09:21 +02:00
|
|
|
while (1) {
|
2015-09-03 04:40:03 +02:00
|
|
|
int sentBytes = send(socket, (const char*)&tosend[packet.transferred], tosend.size() - packet.transferred, 0);
|
|
|
|
if (sentBytes == SOCKET_ERROR) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
packet.transferred += sentBytes;
|
|
|
|
if (packet.transferred == tosend.size()) {
|
|
|
|
return true;
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
}
|
2015-09-03 04:40:03 +02:00
|
|
|
return false;
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
void NetworkConnection::QueuePacket(std::unique_ptr<NetworkPacket> packet, bool front)
|
2015-07-07 16:09:21 +02:00
|
|
|
{
|
2015-11-02 01:28:53 +01:00
|
|
|
if (authstatus == NETWORK_AUTH_OK || !packet->CommandRequiresAuth()) {
|
2015-08-07 17:11:10 +02:00
|
|
|
packet->size = (uint16)packet->data->size();
|
2015-11-04 00:31:09 +01:00
|
|
|
if (front) {
|
|
|
|
outboundpackets.push_front(std::move(packet));
|
|
|
|
} else {
|
|
|
|
outboundpackets.push_back(std::move(packet));
|
|
|
|
}
|
2015-07-15 08:23:04 +02:00
|
|
|
}
|
2015-07-07 16:09:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void NetworkConnection::SendQueuedPackets()
|
|
|
|
{
|
|
|
|
while (outboundpackets.size() > 0 && SendPacket(*(outboundpackets.front()).get())) {
|
|
|
|
outboundpackets.remove(outboundpackets.front());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-03 04:40:03 +02:00
|
|
|
bool NetworkConnection::SetTCPNoDelay(bool on)
|
|
|
|
{
|
|
|
|
return setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&on, sizeof(on)) == 0;
|
|
|
|
}
|
|
|
|
|
2015-09-24 19:39:15 +02:00
|
|
|
bool NetworkConnection::SetNonBlocking(bool on)
|
|
|
|
{
|
|
|
|
return SetNonBlocking(socket, on);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool NetworkConnection::SetNonBlocking(SOCKET socket, bool on)
|
|
|
|
{
|
|
|
|
#ifdef _WIN32
|
|
|
|
u_long nonblocking = on;
|
|
|
|
return ioctlsocket(socket, FIONBIO, &nonblocking) == 0;
|
|
|
|
#else
|
|
|
|
int flags = fcntl(socket, F_GETFL, 0);
|
|
|
|
return fcntl(socket, F_SETFL, on ? (flags | O_NONBLOCK) : (flags & ~O_NONBLOCK)) == 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-11-01 08:50:44 +01:00
|
|
|
void NetworkConnection::ResetLastPacketTime()
|
|
|
|
{
|
|
|
|
last_packet_time = SDL_GetTicks();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool NetworkConnection::ReceivedPacketRecently()
|
|
|
|
{
|
|
|
|
if (SDL_TICKS_PASSED(SDL_GetTicks(), last_packet_time + 7000)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
NetworkAddress::NetworkAddress()
|
|
|
|
{
|
|
|
|
ss = std::make_shared<sockaddr_storage>();
|
|
|
|
ss_len = std::make_shared<int>();
|
|
|
|
status = std::make_shared<int>();
|
|
|
|
*status = RESOLVE_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
void NetworkAddress::Resolve(const char* host, unsigned short port, bool nonblocking)
|
|
|
|
{
|
|
|
|
// A non-blocking hostname resolver
|
|
|
|
*status = RESOLVE_INPROGRESS;
|
|
|
|
mutex = SDL_CreateMutex();
|
|
|
|
cond = SDL_CreateCond();
|
|
|
|
NetworkAddress::host = host;
|
|
|
|
NetworkAddress::port = port;
|
|
|
|
SDL_LockMutex(mutex);
|
|
|
|
SDL_Thread* thread = SDL_CreateThread(ResolveFunc, 0, this);
|
|
|
|
// The mutex/cond is to make sure ResolveFunc doesn't ever get a dangling pointer
|
|
|
|
SDL_CondWait(cond, mutex);
|
|
|
|
SDL_UnlockMutex(mutex);
|
|
|
|
SDL_DestroyCond(cond);
|
|
|
|
SDL_DestroyMutex(mutex);
|
|
|
|
if (!nonblocking) {
|
|
|
|
int status;
|
|
|
|
SDL_WaitThread(thread, &status);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int NetworkAddress::GetResolveStatus(void)
|
|
|
|
{
|
|
|
|
return *status;
|
|
|
|
}
|
|
|
|
|
|
|
|
int NetworkAddress::ResolveFunc(void* pointer)
|
|
|
|
{
|
|
|
|
// Copy data for thread safety
|
|
|
|
NetworkAddress * networkaddress = (NetworkAddress*)pointer;
|
|
|
|
SDL_LockMutex(networkaddress->mutex);
|
|
|
|
std::string host;
|
|
|
|
if (networkaddress->host) host = networkaddress->host;
|
|
|
|
std::string port = std::to_string(networkaddress->port);
|
|
|
|
std::shared_ptr<sockaddr_storage> ss = networkaddress->ss;
|
|
|
|
std::shared_ptr<int> ss_len = networkaddress->ss_len;
|
|
|
|
std::shared_ptr<int> status = networkaddress->status;
|
|
|
|
SDL_CondSignal(networkaddress->cond);
|
|
|
|
SDL_UnlockMutex(networkaddress->mutex);
|
|
|
|
|
|
|
|
// Perform the resolve
|
|
|
|
addrinfo hints;
|
|
|
|
addrinfo* res;
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_family = AF_UNSPEC;
|
|
|
|
if (host.length() == 0) {
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
|
|
|
}
|
|
|
|
getaddrinfo(host.length() == 0 ? NULL : host.c_str(), port.c_str(), &hints, &res);
|
|
|
|
if (res) {
|
|
|
|
memcpy(&(*ss), res->ai_addr, res->ai_addrlen);
|
|
|
|
*ss_len = res->ai_addrlen;
|
|
|
|
*status = RESOLVE_OK;
|
2015-10-29 21:41:49 +01:00
|
|
|
freeaddrinfo(res);
|
2015-10-27 04:43:33 +01:00
|
|
|
} else {
|
|
|
|
*status = RESOLVE_FAILED;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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;
|
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;
|
2015-07-10 21:53:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
Network::~Network()
|
|
|
|
{
|
|
|
|
Close();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Network::Init()
|
|
|
|
{
|
2015-09-24 19:39:15 +02:00
|
|
|
#ifdef _WIN32
|
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
|
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-07-10 21:53:41 +02:00
|
|
|
if (mode == NETWORK_MODE_CLIENT) {
|
2015-10-27 04:43:33 +01:00
|
|
|
closesocket(server_connection.socket);
|
2015-07-10 21:53:41 +02:00
|
|
|
} else
|
|
|
|
if (mode == NETWORK_MODE_SERVER) {
|
|
|
|
closesocket(listening_socket);
|
|
|
|
}
|
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;
|
|
|
|
server_connection.authstatus = NETWORK_AUTH_NONE;
|
2015-11-01 08:50:44 +01:00
|
|
|
server_connection.last_disconnect_reason = NULL;
|
2015-07-16 19:32:43 +02:00
|
|
|
|
|
|
|
client_connection_list.clear();
|
|
|
|
game_command_queue.clear();
|
|
|
|
player_list.clear();
|
|
|
|
|
2015-09-24 19:39:15 +02:00
|
|
|
#ifdef _WIN32
|
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
|
|
|
|
|
|
|
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
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
server_address.Resolve(host, port);
|
|
|
|
status = NETWORK_STATUS_RESOLVING;
|
2015-09-24 19:30:14 +02:00
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
window_network_status_open("Resolving...");
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
mode = NETWORK_MODE_CLIENT;
|
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
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
NetworkAddress networkaddress;
|
|
|
|
networkaddress.Resolve(address, port, false);
|
|
|
|
|
2015-02-12 03:01:02 +01:00
|
|
|
log_verbose("Begin listening for clients");
|
2015-10-27 04:43:33 +01:00
|
|
|
listening_socket = socket(networkaddress.ss->ss_family, SOCK_STREAM, IPPROTO_TCP);
|
2015-07-10 21:53:41 +02:00
|
|
|
if (listening_socket == INVALID_SOCKET) {
|
2015-02-12 03:01:02 +01:00
|
|
|
log_error("Unable to create socket.");
|
2015-07-10 21:53:41 +02:00
|
|
|
return false;
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
// Turn off IPV6_V6ONLY so we can accept both v4 and v6 connections
|
|
|
|
int value = 0;
|
|
|
|
if (setsockopt(listening_socket, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&value, sizeof(value)) != 0) {
|
|
|
|
log_error("IPV6_V6ONLY failed. %d", LAST_SOCKET_ERROR());
|
|
|
|
}
|
2015-07-10 21:53:41 +02:00
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
if (bind(listening_socket, (sockaddr*)&(*networkaddress.ss), (*networkaddress.ss_len)) != 0) {
|
2015-07-10 21:53:41 +02:00
|
|
|
closesocket(listening_socket);
|
2015-02-12 03:01:02 +01:00
|
|
|
log_error("Unable to bind to socket.");
|
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
|
|
|
if (listen(listening_socket, SOMAXCONN) != 0) {
|
|
|
|
closesocket(listening_socket);
|
2015-02-12 03:01:02 +01:00
|
|
|
log_error("Unable to listen on socket.");
|
2015-07-10 21:53:41 +02:00
|
|
|
return false;
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-09-24 19:39:15 +02:00
|
|
|
if (!NetworkConnection::SetNonBlocking(listening_socket, true)) {
|
2015-07-10 21:53:41 +02:00
|
|
|
closesocket(listening_socket);
|
2015-02-12 12:30:57 +01:00
|
|
|
log_error("Failed to set non-blocking mode.");
|
2015-07-10 21:53:41 +02:00
|
|
|
return false;
|
2015-02-12 12:30:57 +01:00
|
|
|
}
|
2015-07-07 16:09:21 +02:00
|
|
|
|
2015-08-20 02:26:42 +02:00
|
|
|
NetworkPlayer* player = AddPlayer(gConfigNetwork.player_name);
|
2015-07-16 19:32:43 +02:00
|
|
|
player->flags |= NETWORK_PLAYER_FLAG_ISSERVER;
|
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");
|
2015-07-07 16:09:21 +02:00
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
mode = NETWORK_MODE_SERVER;
|
2015-11-04 00:31:09 +01:00
|
|
|
status = NETWORK_STATUS_CONNECTED;
|
|
|
|
listening_port = port;
|
|
|
|
|
|
|
|
Advertise();
|
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) {
|
|
|
|
return server_connection.authstatus;
|
|
|
|
} 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-04 00:31:09 +01:00
|
|
|
if (SDL_TICKS_PASSED(SDL_GetTicks(), last_advertise_time + 60000)) {
|
|
|
|
Advertise();
|
|
|
|
}
|
2015-08-16 00:19:15 +02:00
|
|
|
SOCKET socket = accept(listening_socket, NULL, NULL);
|
|
|
|
if (socket == INVALID_SOCKET) {
|
2015-09-24 19:39:15 +02:00
|
|
|
if (LAST_SOCKET_ERROR() != EWOULDBLOCK) {
|
2015-08-16 00:19:15 +02:00
|
|
|
PrintError();
|
|
|
|
log_error("Failed to accept client.");
|
2015-07-17 02:24:39 +02:00
|
|
|
}
|
2015-08-16 00:19:15 +02:00
|
|
|
} else {
|
2015-09-24 19:39:15 +02:00
|
|
|
if (!NetworkConnection::SetNonBlocking(socket, true)) {
|
2015-08-16 00:19:15 +02:00
|
|
|
closesocket(socket);
|
|
|
|
log_error("Failed to set non-blocking mode.");
|
2015-07-10 21:53:41 +02:00
|
|
|
} else {
|
2015-08-16 00:19:15 +02:00
|
|
|
AddClient(socket);
|
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
|
|
|
bool connectfailed = false;
|
|
|
|
switch(status){
|
|
|
|
case NETWORK_STATUS_RESOLVING:{
|
2015-11-02 01:28:53 +01:00
|
|
|
if (server_address.GetResolveStatus() == NetworkAddress::RESOLVE_OK) {
|
2015-10-27 04:43:33 +01:00
|
|
|
server_connection.socket = socket(server_address.ss->ss_family, SOCK_STREAM, IPPROTO_TCP);
|
|
|
|
if (server_connection.socket == INVALID_SOCKET) {
|
|
|
|
log_error("Unable to create socket.");
|
|
|
|
connectfailed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
server_connection.SetTCPNoDelay(true);
|
|
|
|
if (!server_connection.SetNonBlocking(true)) {
|
|
|
|
log_error("Failed to set non-blocking mode.");
|
|
|
|
connectfailed = true;
|
|
|
|
break;
|
|
|
|
}
|
2015-09-05 19:46:13 +02:00
|
|
|
|
2015-10-27 04:43:33 +01:00
|
|
|
if (connect(server_connection.socket, (sockaddr *)&(*server_address.ss), (*server_address.ss_len)) == SOCKET_ERROR && (LAST_SOCKET_ERROR() == EINPROGRESS || LAST_SOCKET_ERROR() == EWOULDBLOCK)){
|
|
|
|
window_network_status_open("Connecting...");
|
|
|
|
server_connect_time = SDL_GetTicks();
|
|
|
|
status = NETWORK_STATUS_CONNECTING;
|
|
|
|
} else {
|
|
|
|
log_error("connect() failed %d", LAST_SOCKET_ERROR());
|
|
|
|
connectfailed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
log_error("Could not resolve address.");
|
|
|
|
connectfailed = true;
|
|
|
|
}
|
|
|
|
}break;
|
|
|
|
case NETWORK_STATUS_CONNECTING:{
|
|
|
|
int error = 0;
|
|
|
|
socklen_t len = sizeof(error);
|
2015-10-29 21:41:49 +01:00
|
|
|
int result = getsockopt(server_connection.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
|
2015-11-02 01:28:53 +01:00
|
|
|
if (result != 0) {
|
2015-10-29 21:41:49 +01:00
|
|
|
log_error("getsockopt failed with error %d", LAST_SOCKET_ERROR());
|
|
|
|
break;
|
|
|
|
}
|
2015-10-27 04:43:33 +01:00
|
|
|
if (error != 0) {
|
|
|
|
log_error("Connection failed %d", error);
|
|
|
|
connectfailed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (SDL_TICKS_PASSED(SDL_GetTicks(), server_connect_time + 3000)) {
|
|
|
|
log_error("Connection timed out.");
|
|
|
|
connectfailed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
fd_set writeFD;
|
|
|
|
FD_ZERO(&writeFD);
|
|
|
|
FD_SET(server_connection.socket, &writeFD);
|
|
|
|
timeval timeout;
|
|
|
|
timeout.tv_sec = 0;
|
|
|
|
timeout.tv_usec = 0;
|
|
|
|
if (select(server_connection.socket + 1, NULL, &writeFD, NULL, &timeout) > 0) {
|
2015-10-29 21:41:49 +01:00
|
|
|
error = 0;
|
2015-10-27 04:43:33 +01:00
|
|
|
socklen_t len = sizeof(error);
|
2015-10-29 21:41:49 +01:00
|
|
|
result = getsockopt(server_connection.socket, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
|
2015-11-02 01:28:53 +01:00
|
|
|
if (result != 0) {
|
2015-10-29 21:41:49 +01:00
|
|
|
log_error("getsockopt failed with error %d", LAST_SOCKET_ERROR());
|
|
|
|
break;
|
|
|
|
}
|
2015-10-27 04:43:33 +01:00
|
|
|
if (error == 0) {
|
|
|
|
status = NETWORK_STATUS_CONNECTED;
|
2015-11-01 08:50:44 +01:00
|
|
|
server_connection.ResetLastPacketTime();
|
2015-11-04 00:31:09 +01:00
|
|
|
Client_Send_AUTH(gConfigNetwork.player_name, "");
|
2015-10-27 04:43:33 +01:00
|
|
|
window_network_status_open("Authenticating...");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}break;
|
|
|
|
case NETWORK_STATUS_CONNECTED:
|
|
|
|
if (!ProcessConnection(server_connection)) {
|
2015-11-04 00:31:09 +01:00
|
|
|
std::string errormsg = "Disconnected";
|
2015-11-01 08:50:44 +01:00
|
|
|
if (server_connection.last_disconnect_reason) {
|
2015-11-04 00:31:09 +01:00
|
|
|
errormsg += ": ";
|
|
|
|
errormsg += server_connection.last_disconnect_reason;
|
2015-11-01 08:50:44 +01:00
|
|
|
}
|
2015-11-04 00:31:09 +01:00
|
|
|
window_network_status_open(errormsg.c_str());
|
2015-09-05 19:46:13 +02:00
|
|
|
Close();
|
|
|
|
}
|
2015-10-27 04:43:33 +01:00
|
|
|
ProcessGameCommandQueue();
|
|
|
|
|
|
|
|
// Check synchronisation
|
|
|
|
if (!_desynchronised && !CheckSRAND(RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32), RCT2_GLOBAL(RCT2_ADDRESS_SCENARIO_SRAND_0, uint32))) {
|
|
|
|
_desynchronised = true;
|
|
|
|
window_network_status_open("Network desync detected");
|
|
|
|
if (!gConfigNetwork.stay_connected) {
|
|
|
|
Close();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (connectfailed) {
|
|
|
|
Close();
|
|
|
|
window_network_status_close();
|
|
|
|
window_error_open(STR_UNABLE_TO_CONNECT_TO_SERVER, STR_NONE);
|
2015-08-14 17:59:27 +02:00
|
|
|
}
|
2015-07-08 03:21:05 +02:00
|
|
|
}
|
2015-02-12 12:30:57 +01:00
|
|
|
|
2015-07-17 02:24:39 +02:00
|
|
|
NetworkPlayer* Network::GetPlayerByID(int id) {
|
|
|
|
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()) {
|
|
|
|
return (*it).get();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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);
|
2015-11-01 08:50:44 +01:00
|
|
|
safe_strncpy(lineCh, (const char*)fromplayer->name, sizeof(fromplayer->name));
|
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);
|
|
|
|
safe_strncpy(lineCh, text, 800);
|
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;
|
|
|
|
if (srand0 != server_srand0) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-11-02 01:28:53 +01:00
|
|
|
void Network::KickPlayer(int playerId)
|
|
|
|
{
|
|
|
|
NetworkPlayer *player = GetPlayerByID(playerId);
|
|
|
|
for(auto it = client_connection_list.begin(); it != client_connection_list.end(); it++) {
|
|
|
|
if ((*it)->player->id == playerId) {
|
|
|
|
// Disconnect the client gracefully
|
|
|
|
(*it)->last_disconnect_reason = "Kicked";
|
|
|
|
Server_Send_SETDISCONNECTMSG(*(*it), "Get out of the server!");
|
|
|
|
shutdown((*it)->socket, SHUT_RD);
|
|
|
|
(*it)->SendQueuedPackets();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::SetPassword(const char* password)
|
|
|
|
{
|
2015-11-04 00:31:09 +01:00
|
|
|
Network::password = password;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::ShutdownClient()
|
|
|
|
{
|
|
|
|
if (GetMode() == NETWORK_MODE_CLIENT) {
|
|
|
|
shutdown(server_connection.socket, SHUT_RDWR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Network::Advertise()
|
|
|
|
{
|
|
|
|
if (gConfigNetwork.advertise && strlen(gConfigNetwork.master_url) > 0) {
|
|
|
|
last_advertise_time = SDL_GetTicks();
|
|
|
|
#ifndef DISABLE_HTTP
|
|
|
|
std::string url = gConfigNetwork.master_url + std::string("?port=") + std::to_string(listening_port);
|
|
|
|
http_request_json_async(url.c_str(), [](http_json_response *response)->void{});
|
|
|
|
#endif
|
|
|
|
}
|
2015-11-02 01:28:53 +01:00
|
|
|
}
|
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
void Network::Client_Send_AUTH(const char* name, const char* password)
|
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;
|
2015-11-04 00:31:09 +01:00
|
|
|
packet->WriteString(OPENRCT2_VERSION);
|
2015-07-15 08:23:04 +02:00
|
|
|
packet->WriteString(name);
|
|
|
|
packet->WriteString(password);
|
|
|
|
server_connection.authstatus = NETWORK_AUTH_REQUESTED;
|
|
|
|
server_connection.QueuePacket(std::move(packet));
|
|
|
|
}
|
|
|
|
|
2015-11-02 04:12:14 +01:00
|
|
|
void Network::Server_Send_AUTH(NetworkConnection& connection)
|
|
|
|
{
|
|
|
|
uint8 new_playerid = 0;
|
|
|
|
if (connection.player) {
|
|
|
|
new_playerid = connection.player->id;
|
|
|
|
}
|
|
|
|
std::unique_ptr<NetworkPacket> packet = std::move(NetworkPacket::Allocate());
|
|
|
|
*packet << (uint32)NETWORK_COMMAND_AUTH << (uint32)connection.authstatus << (uint8)new_playerid;
|
|
|
|
connection.QueuePacket(std::move(packet));
|
|
|
|
if (connection.authstatus != NETWORK_AUTH_OK && connection.authstatus != NETWORK_AUTH_REQUIREPASSWORD) {
|
|
|
|
shutdown(connection.socket, SHUT_RD);
|
|
|
|
connection.SendQueuedPackets();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-31 16:14:44 +02:00
|
|
|
void Network::Server_Send_MAP(NetworkConnection* connection)
|
2015-07-15 08:23:04 +02:00
|
|
|
{
|
|
|
|
int buffersize = 0x600000;
|
|
|
|
std::vector<uint8> buffer(buffersize);
|
|
|
|
SDL_RWops* rw = SDL_RWFromMem(&buffer[0], buffersize);
|
2015-07-31 16:14:44 +02:00
|
|
|
scenario_save_network(rw);
|
2015-07-15 08:23:04 +02:00
|
|
|
int size = (int)SDL_RWtell(rw);
|
|
|
|
int chunksize = 1000;
|
|
|
|
for (int i = 0; i < size; i += chunksize) {
|
2015-08-20 06:59:55 +02:00
|
|
|
int datasize = (std::min)(chunksize, size - i);
|
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_MAP << (uint32)size << (uint32)i;
|
|
|
|
packet->Write(&buffer[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
|
|
|
}
|
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());
|
2015-10-20 20:16:30 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_GAMECMD << (uint32)RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32) << 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());
|
2015-10-20 20:16:30 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_GAMECMD << (uint32)RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32) << 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());
|
2015-07-30 16:34:17 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_TICK << (uint32)RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32) << (uint32)RCT2_GLOBAL(RCT2_ADDRESS_SCENARIO_SRAND_0, uint32);
|
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());
|
2015-07-16 19:32:43 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_PLAYERLIST << (uint32)player_list.size();
|
|
|
|
for (unsigned int i = 0; i < player_list.size(); i++) {
|
|
|
|
packet->WriteString((const char*)player_list[i]->name);
|
|
|
|
*packet << player_list[i]->id << player_list[i]->flags;
|
|
|
|
}
|
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++) {
|
|
|
|
(*it)->ping_time = SDL_GetTicks();
|
|
|
|
}
|
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());
|
2015-07-17 02:24:39 +02:00
|
|
|
*packet << (uint32)NETWORK_COMMAND_PINGLIST << (uint32)player_list.size();
|
|
|
|
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();
|
|
|
|
json_object_set(obj, "name", json_string(gConfigNetwork.server_name));
|
2015-11-08 00:47:50 +01:00
|
|
|
json_object_set(obj, "requiresPassword", json_boolean(password.size() > 0));
|
2015-11-04 00:31:09 +01:00
|
|
|
json_object_set(obj, "version", json_string(OPENRCT2_VERSION));
|
|
|
|
json_object_set(obj, "players", json_integer(player_list.size()));
|
2015-11-08 00:47:50 +01:00
|
|
|
json_object_set(obj, "maxPlayers", json_integer(gConfigNetwork.maxplayers));
|
|
|
|
json_object_set(obj, "description", json_string(gConfigNetwork.server_description));
|
2015-11-04 00:31:09 +01:00
|
|
|
packet->WriteString(json_dumps(obj, 0));
|
|
|
|
json_object_clear(obj);
|
|
|
|
#endif
|
|
|
|
connection.QueuePacket(std::move(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
|
|
|
|
PrintError();
|
2015-11-01 08:50:44 +01:00
|
|
|
if (!connection.last_disconnect_reason) {
|
|
|
|
connection.last_disconnect_reason = "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
|
2015-07-15 08:23:04 +02:00
|
|
|
ProcessPacket(connection, connection.inboundpacket);
|
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()) {
|
2015-11-04 00:31:09 +01:00
|
|
|
if (!connection.last_disconnect_reason) {
|
|
|
|
connection.last_disconnect_reason = "No Data";
|
|
|
|
}
|
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
|
|
|
// printf("RECV %s\n", NetworkCommandNames[command]);
|
|
|
|
switch (gNetwork.GetMode()) {
|
|
|
|
case NETWORK_MODE_SERVER:
|
2015-07-15 08:23:04 +02:00
|
|
|
if (server_command_handlers[command]) {
|
2015-11-04 00:31:09 +01: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
|
|
|
{
|
2015-07-10 21:53:41 +02:00
|
|
|
while (game_command_queue.begin() != game_command_queue.end() && game_command_queue.begin()->tick == RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32)) {
|
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
game_do_command_p(gc.esi, (int*)&gc.eax, (int*)&gc.ebx, (int*)&gc.ecx, (int*)&gc.edx, (int*)&gc.esi, (int*)&gc.edi, (int*)&gc.ebp);
|
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
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
void Network::AddClient(SOCKET 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
|
|
|
|
connection->socket = socket;
|
2015-09-03 04:40:03 +02:00
|
|
|
connection->SetTCPNoDelay(true);
|
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
|
|
|
{
|
2015-07-16 19:32:43 +02:00
|
|
|
NetworkPlayer* connection_player = connection->player;
|
2015-07-19 01:57:42 +02:00
|
|
|
if (connection_player) {
|
|
|
|
char text[256];
|
2015-08-07 17:11:10 +02:00
|
|
|
char* lineCh = text;
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_OUTLINE);
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_RED);
|
2015-11-01 08:50:44 +01:00
|
|
|
char reasonstr[100];
|
|
|
|
reasonstr[0] = 0;
|
2015-11-04 00:31:09 +01:00
|
|
|
if (connection->last_disconnect_reason && strlen(connection->last_disconnect_reason) < sizeof(reasonstr)) {
|
2015-11-01 08:50:44 +01:00
|
|
|
sprintf(reasonstr, " (%s)", connection->last_disconnect_reason);
|
|
|
|
}
|
|
|
|
sprintf(lineCh, "%s has disconnected%s", connection_player->name, reasonstr);
|
2015-07-19 01:57:42 +02:00
|
|
|
chat_history_add(text);
|
|
|
|
gNetwork.Server_Send_CHAT(text);
|
|
|
|
}
|
2015-07-16 19:32:43 +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());
|
|
|
|
client_connection_list.remove(connection);
|
|
|
|
Server_Send_PLAYERLIST();
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-07-17 02:24:39 +02:00
|
|
|
NetworkPlayer* Network::AddPlayer(const char* name)
|
|
|
|
{
|
|
|
|
NetworkPlayer* addedplayer = 0;
|
|
|
|
int newid = -1;
|
|
|
|
if (GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
// Find first unused player id
|
|
|
|
for (int id = 0; id < 255; id++) {
|
|
|
|
if (std::find_if(player_list.begin(), player_list.end(), [&id](std::unique_ptr<NetworkPlayer> const& player) { return player->id == id; }) == player_list.end()) {
|
|
|
|
newid = id;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
newid = 0;
|
|
|
|
}
|
|
|
|
if (newid != -1) {
|
|
|
|
std::unique_ptr<NetworkPlayer> player(new NetworkPlayer(name)); // change to make_unique in c++14
|
|
|
|
player->id = newid;
|
|
|
|
addedplayer = player.get();
|
|
|
|
player_list.push_back(std::move(player));
|
|
|
|
if (GetMode() == NETWORK_MODE_SERVER) {
|
|
|
|
Server_Send_PLAYERLIST();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return addedplayer;
|
|
|
|
}
|
|
|
|
|
2015-07-10 21:53:41 +02:00
|
|
|
void Network::PrintError()
|
2015-02-12 03:01:02 +01:00
|
|
|
{
|
2015-09-24 19:39:15 +02:00
|
|
|
#ifdef _WIN32
|
2015-02-12 12:30:57 +01:00
|
|
|
wchar_t *s = NULL;
|
2015-09-24 19:39:15 +02:00
|
|
|
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, LAST_SOCKET_ERROR(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&s, 0, NULL);
|
2015-02-12 12:30:57 +01:00
|
|
|
fprintf(stderr, "%S\n", s);
|
|
|
|
LocalFree(s);
|
2015-09-24 19:39:15 +02:00
|
|
|
#else
|
|
|
|
char *s = strerror(LAST_SOCKET_ERROR());
|
|
|
|
fprintf(stderr, "%s\n", s);
|
|
|
|
#endif
|
2015-10-20 20:16:30 +02:00
|
|
|
|
2015-02-12 03:01:02 +01:00
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
int Network::Client_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
2015-07-24 01:22:03 +02:00
|
|
|
packet >> (uint32&)connection.authstatus >> (uint8&)player_id;
|
2015-11-02 01:28:53 +01:00
|
|
|
switch(connection.authstatus) {
|
|
|
|
case NETWORK_AUTH_BADNAME:
|
|
|
|
connection.last_disconnect_reason = "Bad Player Name";
|
|
|
|
shutdown(connection.socket, SHUT_RDWR);
|
|
|
|
break;
|
|
|
|
case NETWORK_AUTH_BADVERSION:
|
|
|
|
connection.last_disconnect_reason = "Incorrect Software Version";
|
|
|
|
shutdown(connection.socket, SHUT_RDWR);
|
|
|
|
break;
|
|
|
|
case NETWORK_AUTH_BADPASSWORD:
|
|
|
|
connection.last_disconnect_reason = "Bad Password";
|
|
|
|
shutdown(connection.socket, SHUT_RDWR);
|
|
|
|
break;
|
2015-11-04 00:31:09 +01:00
|
|
|
case NETWORK_AUTH_FULL:
|
|
|
|
connection.last_disconnect_reason = "Server Full";
|
|
|
|
shutdown(connection.socket, SHUT_RDWR);
|
|
|
|
break;
|
2015-11-02 04:12:14 +01:00
|
|
|
case NETWORK_AUTH_REQUIREPASSWORD:
|
|
|
|
window_network_status_open_password();
|
|
|
|
break;
|
2015-11-02 01:28:53 +01:00
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
int Network::Server_Handle_AUTH(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
2015-07-16 19:32:43 +02:00
|
|
|
if (connection.authstatus != NETWORK_AUTH_OK) {
|
|
|
|
const char* gameversion = packet.ReadString();
|
|
|
|
const char* name = packet.ReadString();
|
|
|
|
const char* password = packet.ReadString();
|
|
|
|
if (!gameversion || strcmp(gameversion, OPENRCT2_VERSION) != 0) {
|
|
|
|
connection.authstatus = NETWORK_AUTH_BADVERSION;
|
|
|
|
} else
|
|
|
|
if (!name) {
|
|
|
|
connection.authstatus = NETWORK_AUTH_BADNAME;
|
|
|
|
} else
|
2015-11-04 00:31:09 +01:00
|
|
|
if ((!password || strlen(password) == 0) && Network::password.size() > 0) {
|
2015-11-02 04:12:14 +01:00
|
|
|
connection.authstatus = NETWORK_AUTH_REQUIREPASSWORD;
|
|
|
|
} else
|
2015-11-04 00:31:09 +01:00
|
|
|
if (password && Network::password != password) {
|
2015-07-16 19:32:43 +02:00
|
|
|
connection.authstatus = NETWORK_AUTH_BADPASSWORD;
|
2015-11-04 00:31:09 +01:00
|
|
|
} else
|
|
|
|
if (gConfigNetwork.maxplayers <= player_list.size()) {
|
|
|
|
connection.authstatus = NETWORK_AUTH_FULL;
|
2015-07-16 19:32:43 +02:00
|
|
|
} else {
|
|
|
|
connection.authstatus = NETWORK_AUTH_OK;
|
2015-07-17 02:24:39 +02:00
|
|
|
NetworkPlayer* player = AddPlayer(name);
|
|
|
|
connection.player = player;
|
2015-07-24 01:22:03 +02:00
|
|
|
if (player) {
|
|
|
|
char text[256];
|
2015-08-07 17:11:10 +02:00
|
|
|
char* lineCh = text;
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_OUTLINE);
|
|
|
|
lineCh = utf8_write_codepoint(lineCh, FORMAT_GREEN);
|
|
|
|
sprintf(lineCh, "%s has joined the game", player->name);
|
2015-07-24 01:22:03 +02:00
|
|
|
chat_history_add(text);
|
|
|
|
gNetwork.Server_Send_CHAT(text);
|
2015-07-31 16:14:44 +02:00
|
|
|
Server_Send_MAP(&connection);
|
2015-07-24 01:22:03 +02:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Network::Client_Handle_MAP(NetworkConnection& connection, NetworkPacket& packet)
|
2015-07-15 06:40:22 +02:00
|
|
|
{
|
|
|
|
uint32 size, offset;
|
|
|
|
packet >> size >> offset;
|
|
|
|
if (offset > 0x600000) {
|
|
|
|
// too big
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
int chunksize = packet.size - packet.read;
|
2015-07-19 01:57:42 +02:00
|
|
|
if (chunksize <= 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
if (offset + chunksize > chunk_buffer.size()) {
|
|
|
|
chunk_buffer.resize(offset + chunksize);
|
|
|
|
}
|
2015-07-23 00:55:43 +02:00
|
|
|
char status[256];
|
2015-09-24 19:39:15 +02:00
|
|
|
sprintf(status, "Downloading map ... (%lu / %lu)", (offset + chunksize) / 1000, size / 1000);
|
2015-07-23 00:55:43 +02:00
|
|
|
window_network_status_open(status);
|
2015-07-15 06:40:22 +02:00
|
|
|
memcpy(&chunk_buffer[offset], (void*)packet.Read(chunksize), chunksize);
|
|
|
|
if (offset + chunksize == size) {
|
2015-08-16 18:29:47 +02:00
|
|
|
window_network_status_close();
|
|
|
|
|
2015-07-15 06:40:22 +02:00
|
|
|
SDL_RWops* rw = SDL_RWFromMem(&chunk_buffer[0], size);
|
2015-07-31 16:14:44 +02:00
|
|
|
if (game_load_network(rw)) {
|
2015-07-15 06:40:22 +02:00
|
|
|
game_load_init();
|
2015-07-16 19:32:43 +02:00
|
|
|
game_command_queue.clear();
|
2015-07-30 00:30:05 +02:00
|
|
|
server_tick = RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32);
|
2015-07-30 16:34:17 +02:00
|
|
|
server_srand0_tick = 0;
|
2015-08-16 18:29:47 +02:00
|
|
|
// window_network_status_open("Loaded new map from network");
|
2015-09-05 19:46:13 +02:00
|
|
|
_desynchronised = false;
|
2015-07-15 06:40:22 +02:00
|
|
|
}
|
|
|
|
SDL_RWclose(rw);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
int 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
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
int Network::Server_Handle_CHAT(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
2015-11-01 08:50:44 +01:00
|
|
|
const char* text = packet.ReadString();
|
2015-07-19 01:57:42 +02:00
|
|
|
if (text) {
|
|
|
|
const char* formatted = FormatChat(connection.player, text);
|
|
|
|
chat_history_add(formatted);
|
|
|
|
Server_Send_CHAT(formatted);
|
|
|
|
}
|
2015-07-15 08:23:04 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int 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
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
int 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;
|
|
|
|
if (connection.player) {
|
|
|
|
playerid = connection.player->id;
|
|
|
|
}
|
|
|
|
packet >> tick >> args[0] >> args[1] >> args[2] >> args[3] >> args[4] >> args[5] >> args[6] >> callback;
|
|
|
|
Server_Send_GAMECMD(args[0], args[1], args[2], args[3], args[4], args[5], args[6], playerid, callback);
|
2015-07-15 08:23:04 +02:00
|
|
|
game_do_command(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
|
2015-07-15 06:40:22 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-15 08:23:04 +02:00
|
|
|
int 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;
|
|
|
|
packet >> server_tick >> srand0;
|
|
|
|
if (server_srand0_tick == 0) {
|
|
|
|
server_srand0 = srand0;
|
|
|
|
server_srand0_tick = server_tick;
|
|
|
|
}
|
2015-07-15 06:40:22 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:32:43 +02:00
|
|
|
int Network::Client_Handle_PLAYERLIST(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
player_list.clear();
|
|
|
|
uint32 size;
|
|
|
|
packet >> size;
|
|
|
|
for (unsigned int i = 0; i < size; i++) {
|
|
|
|
const char* name = packet.ReadString();
|
2015-07-17 02:24:39 +02:00
|
|
|
NetworkPlayer* player = AddPlayer(name);
|
|
|
|
if (player) {
|
|
|
|
packet >> player->id >> player->flags;
|
|
|
|
if (player->flags & NETWORK_PLAYER_FLAG_ISSERVER) {
|
|
|
|
server_connection.player = player;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Network::Client_Handle_PING(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
Client_Send_PING();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Network::Server_Handle_PING(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
int ping = SDL_GetTicks() - connection.ping_time;
|
|
|
|
if (ping < 0) {
|
|
|
|
ping = 0;
|
|
|
|
}
|
|
|
|
if (connection.player) {
|
|
|
|
connection.player->ping = ping;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Network::Client_Handle_PINGLIST(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
uint32 size;
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-11-01 08:50:44 +01:00
|
|
|
int Network::Client_Handle_SETDISCONNECTMSG(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
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;
|
|
|
|
connection.last_disconnect_reason = msg.c_str();
|
2015-11-01 08:50:44 +01:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-11-04 00:31:09 +01:00
|
|
|
int Network::Server_Handle_GAMEINFO(NetworkConnection& connection, NetworkPacket& packet)
|
|
|
|
{
|
|
|
|
Server_Send_GAMEINFO(connection);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
return (const char*)gNetwork.player_list[index]->name;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2015-11-04 00:31:09 +01:00
|
|
|
gNetwork.Client_Send_AUTH(gConfigNetwork.player_name, password);
|
2015-11-02 04:12:14 +01:00
|
|
|
}
|
|
|
|
|
2015-11-02 01:28:53 +01:00
|
|
|
void network_kick_player(int playerId)
|
2015-10-16 23:20:16 +02:00
|
|
|
{
|
2015-11-02 01:28:53 +01:00
|
|
|
gNetwork.KickPlayer(playerId);
|
2015-10-16 23:20:16 +02: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
|
|
|
}
|
|
|
|
|
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; }
|
2015-08-18 09:30:55 +02:00
|
|
|
uint32 network_get_server_tick() { return RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32); }
|
|
|
|
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; }
|
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_kick_player(int playerId) {}
|
|
|
|
void network_set_password(const char* password) {}
|
2015-10-18 13:02:31 +02:00
|
|
|
uint8 network_get_current_player_id() { return 0; }
|
2015-08-18 09:30:55 +02:00
|
|
|
#endif /* DISABLE_NETWORK */
|