network.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "../stdafx.h"
 
#include "../strings_func.h"
#include "../command_func.h"
#include "../timer/timer_game_tick.h"
#include "../timer/timer_game_economy.h"
#include "network_admin.h"
#include "network_client.h"
#include "network_query.h"
#include "network_server.h"
#include "network_content.h"
#include "network_udp.h"
#include "network_gamelist.h"
#include "network_base.h"
#include "network_coordinator.h"
#include "core/udp.h"
#include "core/host.h"
#include "network_gui.h"
#include "../console_func.h"
#include "../3rdparty/md5/md5.h"
#include "../core/random_func.hpp"
#include "../window_func.h"
#include "../company_func.h"
#include "../company_base.h"
#include "../landscape_type.h"
#include "../rev.h"
#include "../core/pool_func.hpp"
#include "../gfx_func.h"
#include "../error.h"
#include "../misc_cmd.h"
#ifdef DEBUG_DUMP_COMMANDS
# include "../fileio_func.h"
#endif
#include <charconv>
#include <sstream>
#include <iomanip>
 
#include "../safeguards.h"
 
#ifdef DEBUG_DUMP_COMMANDS
bool _ddc_fastforward = true;
#endif /* DEBUG_DUMP_COMMANDS */
 
static_assert(NetworkClientInfoPool::MAX_SIZE == NetworkClientSocketPool::MAX_SIZE);
 
NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo");
INSTANTIATE_POOL_METHODS(NetworkClientInfo)
 
bool _networking;         
bool _network_server;     
bool _network_available;  
bool _network_dedicated;  
bool _is_network_server;  
ClientID _network_own_client_id;      
ClientID _redirect_console_to_client; 
uint8_t _network_reconnect;             
StringList _network_bind_list;        
StringList _network_host_list;        
StringList _network_ban_list;         
uint32_t _frame_counter_server;         
uint32_t _frame_counter_max;            
uint32_t _frame_counter;                
uint32_t _last_sync_frame;              
NetworkAddressList _broadcast_list;   
uint32_t _sync_seed_1;                  
#ifdef NETWORK_SEND_DOUBLE_SEED
uint32_t _sync_seed_2;                  
#endif
uint32_t _sync_frame;                   
bool _network_first_time;             
 
uint8_t _network_clients_connected = 0;
 
extern std::string GenerateUid(std::string_view subject);
 
bool HasClients()
{
  return !NetworkClientSocket::Iterate().empty();
}
 
NetworkClientInfo::~NetworkClientInfo()
{
  /* Delete the chat window, if you were chatting with this client. */
  InvalidateWindowData(WC_SEND_NETWORK_MSG, DESTTYPE_CLIENT, this->client_id);
}
 
/* static */ NetworkClientInfo *NetworkClientInfo::GetByClientID(ClientID client_id)
{
  for (NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
    if (ci->client_id == client_id) return ci;
  }
 
  return nullptr;
}
 
bool NetworkClientInfo::CanJoinCompany(CompanyID company_id) const
{
  Company *c = Company::GetIfValid(company_id);
  return c != nullptr && c->allow_list.Contains(this->public_key);
}
 
bool NetworkCanJoinCompany(CompanyID company_id)
{
  NetworkClientInfo *info = NetworkClientInfo::GetByClientID(_network_own_client_id);
  return info != nullptr && info->CanJoinCompany(company_id);
}
 
/* static */ ServerNetworkGameSocketHandler *ServerNetworkGameSocketHandler::GetByClientID(ClientID client_id)
{
  for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
    if (cs->client_id == client_id) return cs;
  }
 
  return nullptr;
}
 
 
static auto FindKey(auto *authorized_keys, std::string_view authorized_key)
{
  return std::ranges::find_if(*authorized_keys, [authorized_key](auto &value) { return StrEqualsIgnoreCase(value, authorized_key); });
}
 
bool NetworkAuthorizedKeys::Contains(std::string_view key) const
{
  return FindKey(this, key) != this->end();
}
 
bool NetworkAuthorizedKeys::Add(std::string_view key)
{
  if (key.empty()) return false;
 
  auto iter = FindKey(this, key);
  if (iter != this->end()) return false;
 
  this->emplace_back(key);
  return true;
}
 
bool NetworkAuthorizedKeys::Remove(std::string_view key)
{
  auto iter = FindKey(this, key);
  if (iter == this->end()) return false;
 
  this->erase(iter);
  return true;
}
 
 
uint8_t NetworkSpectatorCount()
{
  uint8_t count = 0;
 
  for (const NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
    if (ci->client_playas == COMPANY_SPECTATOR) count++;
  }
 
  /* Don't count a dedicated server as spectator */
  if (_network_dedicated) count--;
 
  return count;
}
 
 
/* This puts a text-message to the console, or in the future, the chat-box,
 *  (to keep it all a bit more general)
 * If 'self_send' is true, this is the client who is sending the message */
void NetworkTextMessage(NetworkAction action, TextColour colour, bool self_send, const std::string &name, const std::string &str, int64_t data, const std::string &data_str)
{
  StringID strid;
  switch (action) {
    case NETWORK_ACTION_SERVER_MESSAGE:
      /* Ignore invalid messages */
      strid = STR_NETWORK_SERVER_MESSAGE;
      colour = CC_DEFAULT;
      break;
    case NETWORK_ACTION_COMPANY_SPECTATOR:
      colour = CC_DEFAULT;
      strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_SPECTATE;
      break;
    case NETWORK_ACTION_COMPANY_JOIN:
      colour = CC_DEFAULT;
      strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_JOIN;
      break;
    case NETWORK_ACTION_COMPANY_NEW:
      colour = CC_DEFAULT;
      strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_NEW;
      break;
    case NETWORK_ACTION_JOIN:
      /* Show the Client ID for the server but not for the client. */
      strid = _network_server ? STR_NETWORK_MESSAGE_CLIENT_JOINED_ID :  STR_NETWORK_MESSAGE_CLIENT_JOINED;
      break;
    case NETWORK_ACTION_LEAVE:          strid = STR_NETWORK_MESSAGE_CLIENT_LEFT; break;
    case NETWORK_ACTION_NAME_CHANGE:    strid = STR_NETWORK_MESSAGE_NAME_CHANGE; break;
    case NETWORK_ACTION_GIVE_MONEY:     strid = STR_NETWORK_MESSAGE_GIVE_MONEY; break;
    case NETWORK_ACTION_CHAT_COMPANY:   strid = self_send ? STR_NETWORK_CHAT_TO_COMPANY : STR_NETWORK_CHAT_COMPANY; break;
    case NETWORK_ACTION_CHAT_CLIENT:    strid = self_send ? STR_NETWORK_CHAT_TO_CLIENT  : STR_NETWORK_CHAT_CLIENT;  break;
    case NETWORK_ACTION_KICKED:         strid = STR_NETWORK_MESSAGE_KICKED; break;
    case NETWORK_ACTION_EXTERNAL_CHAT:  strid = STR_NETWORK_CHAT_EXTERNAL; break;
    default:                            strid = STR_NETWORK_CHAT_ALL; break;
  }
 
  SetDParamStr(0, name);
  SetDParamStr(1, str);
  SetDParam(2, data);
  SetDParamStr(3, data_str);
 
  /* All of these strings start with "***". These characters are interpreted as both left-to-right and
   * right-to-left characters depending on the context. As the next text might be an user's name, the
   * user name's characters will influence the direction of the "***" instead of the language setting
   * of the game. Manually set the direction of the "***" by inserting a text-direction marker. */
  std::ostringstream stream;
  std::ostreambuf_iterator<char> iterator(stream);
  Utf8Encode(iterator, _current_text_dir == TD_LTR ? CHAR_TD_LRM : CHAR_TD_RLM);
  std::string message = stream.str() + GetString(strid);
 
  Debug(desync, 1, "msg: {:08x}; {:02x}; {}", TimerGameEconomy::date, TimerGameEconomy::date_fract, message);
  IConsolePrint(colour, message);
  NetworkAddChatMessage(colour, _settings_client.gui.network_chat_timeout, message);
}
 
/* Calculate the frame-lag of a client */
uint NetworkCalculateLag(const NetworkClientSocket *cs)
{
  int lag = cs->last_frame_server - cs->last_frame;
  /* This client has missed their ACK packet after 1 DAY_TICKS..
   *  so we increase their lag for every frame that passes!
   * The packet can be out by a max of _net_frame_freq */
  if (cs->last_frame_server + Ticks::DAY_TICKS + _settings_client.network.frame_freq < _frame_counter) {
    lag += _frame_counter - (cs->last_frame_server + Ticks::DAY_TICKS + _settings_client.network.frame_freq);
  }
  return lag;
}
 
 
/* There was a non-recoverable error, drop back to the main menu with a nice
 *  error */
void ShowNetworkError(StringID error_string)
{
  _switch_mode = SM_MENU;
  ShowErrorMessage(error_string, INVALID_STRING_ID, WL_CRITICAL);
}
 
StringID GetNetworkErrorMsg(NetworkErrorCode err)
{
  /* List of possible network errors, used by
   * PACKET_SERVER_ERROR and PACKET_CLIENT_ERROR */
  static const StringID network_error_strings[] = {
    STR_NETWORK_ERROR_CLIENT_GENERAL,
    STR_NETWORK_ERROR_CLIENT_DESYNC,
    STR_NETWORK_ERROR_CLIENT_SAVEGAME,
    STR_NETWORK_ERROR_CLIENT_CONNECTION_LOST,
    STR_NETWORK_ERROR_CLIENT_PROTOCOL_ERROR,
    STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH,
    STR_NETWORK_ERROR_CLIENT_NOT_AUTHORIZED,
    STR_NETWORK_ERROR_CLIENT_NOT_EXPECTED,
    STR_NETWORK_ERROR_CLIENT_WRONG_REVISION,
    STR_NETWORK_ERROR_CLIENT_NAME_IN_USE,
    STR_NETWORK_ERROR_CLIENT_WRONG_PASSWORD,
    STR_NETWORK_ERROR_CLIENT_COMPANY_MISMATCH,
    STR_NETWORK_ERROR_CLIENT_KICKED,
    STR_NETWORK_ERROR_CLIENT_CHEATER,
    STR_NETWORK_ERROR_CLIENT_SERVER_FULL,
    STR_NETWORK_ERROR_CLIENT_TOO_MANY_COMMANDS,
    STR_NETWORK_ERROR_CLIENT_TIMEOUT_PASSWORD,
    STR_NETWORK_ERROR_CLIENT_TIMEOUT_COMPUTER,
    STR_NETWORK_ERROR_CLIENT_TIMEOUT_MAP,
    STR_NETWORK_ERROR_CLIENT_TIMEOUT_JOIN,
    STR_NETWORK_ERROR_CLIENT_INVALID_CLIENT_NAME,
    STR_NETWORK_ERROR_CLIENT_NOT_ON_ALLOW_LIST,
    STR_NETWORK_ERROR_CLIENT_NO_AUTHENTICATION_METHOD_AVAILABLE,
  };
  static_assert(lengthof(network_error_strings) == NETWORK_ERROR_END);
 
  if (err >= (ptrdiff_t)lengthof(network_error_strings)) err = NETWORK_ERROR_GENERAL;
 
  return network_error_strings[err];
}
 
void NetworkHandlePauseChange(PauseMode prev_mode, PauseMode changed_mode)
{
  if (!_networking) return;
 
  switch (changed_mode) {
    case PM_PAUSED_NORMAL:
    case PM_PAUSED_JOIN:
    case PM_PAUSED_GAME_SCRIPT:
    case PM_PAUSED_ACTIVE_CLIENTS:
    case PM_PAUSED_LINK_GRAPH: {
      bool changed = ((_pause_mode == PM_UNPAUSED) != (prev_mode == PM_UNPAUSED));
      bool paused = (_pause_mode != PM_UNPAUSED);
      if (!paused && !changed) return;
 
      StringID str;
      if (!changed) {
        int i = -1;
 
        if ((_pause_mode & PM_PAUSED_NORMAL) != PM_UNPAUSED)         SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL);
        if ((_pause_mode & PM_PAUSED_JOIN) != PM_UNPAUSED)           SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS);
        if ((_pause_mode & PM_PAUSED_GAME_SCRIPT) != PM_UNPAUSED)    SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT);
        if ((_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS);
        if ((_pause_mode & PM_PAUSED_LINK_GRAPH) != PM_UNPAUSED)     SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_LINK_GRAPH);
        str = STR_NETWORK_SERVER_MESSAGE_GAME_STILL_PAUSED_1 + i;
      } else {
        switch (changed_mode) {
          case PM_PAUSED_NORMAL:         SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL); break;
          case PM_PAUSED_JOIN:           SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS); break;
          case PM_PAUSED_GAME_SCRIPT:    SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT); break;
          case PM_PAUSED_ACTIVE_CLIENTS: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS); break;
          case PM_PAUSED_LINK_GRAPH:     SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_LINK_GRAPH); break;
          default: NOT_REACHED();
        }
        str = paused ? STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED : STR_NETWORK_SERVER_MESSAGE_GAME_UNPAUSED;
      }
 
      NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE, CC_DEFAULT, false, "", GetString(str));
      break;
    }
 
    default:
      return;
  }
}
 
 
static void CheckPauseHelper(bool pause, PauseMode pm)
{
  if (pause == ((_pause_mode & pm) != PM_UNPAUSED)) return;
 
  Command<CMD_PAUSE>::Post(pm, pause);
}
 
static uint NetworkCountActiveClients()
{
  uint count = 0;
 
  for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
    if (cs->status != NetworkClientSocket::STATUS_ACTIVE) continue;
    if (!Company::IsValidID(cs->GetInfo()->client_playas)) continue;
    count++;
  }
 
  return count;
}
 
static void CheckMinActiveClients()
{
  if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
      !_network_dedicated ||
      (_settings_client.network.min_active_clients == 0 && (_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) == PM_UNPAUSED)) {
    return;
  }
  CheckPauseHelper(NetworkCountActiveClients() < _settings_client.network.min_active_clients, PM_PAUSED_ACTIVE_CLIENTS);
}
 
static bool NetworkHasJoiningClient()
{
  for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
    if (cs->status >= NetworkClientSocket::STATUS_AUTHORIZED && cs->status < NetworkClientSocket::STATUS_ACTIVE) return true;
  }
 
  return false;
}
 
static void CheckPauseOnJoin()
{
  if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
      (!_settings_client.network.pause_on_join && (_pause_mode & PM_PAUSED_JOIN) == PM_UNPAUSED)) {
    return;
  }
  CheckPauseHelper(NetworkHasJoiningClient(), PM_PAUSED_JOIN);
}
 
std::string_view ParseCompanyFromConnectionString(const std::string &connection_string, CompanyID *company_id)
{
  std::string_view ip = connection_string;
  if (company_id == nullptr) return ip;
 
  size_t offset = ip.find_last_of('#');
  if (offset != std::string::npos) {
    std::string_view company_string = ip.substr(offset + 1);
    ip = ip.substr(0, offset);
 
    uint8_t company_value;
    auto [_, err] = std::from_chars(company_string.data(), company_string.data() + company_string.size(), company_value);
    if (err == std::errc()) {
      if (company_value != COMPANY_NEW_COMPANY && company_value != COMPANY_SPECTATOR) {
        if (company_value > MAX_COMPANIES || company_value == 0) {
          *company_id = COMPANY_SPECTATOR;
        } else {
          /* "#1" means the first company, which has index 0. */
          *company_id = (CompanyID)(company_value - 1);
        }
      } else {
        *company_id = (CompanyID)company_value;
      }
    }
  }
 
  return ip;
}
 
std::string_view ParseFullConnectionString(const std::string &connection_string, uint16_t &port, CompanyID *company_id)
{
  std::string_view ip = ParseCompanyFromConnectionString(connection_string, company_id);
 
  size_t port_offset = ip.find_last_of(':');
  size_t ipv6_close = ip.find_last_of(']');
  if (port_offset != std::string::npos && (ipv6_close == std::string::npos || ipv6_close < port_offset)) {
    std::string_view port_string = ip.substr(port_offset + 1);
    ip = ip.substr(0, port_offset);
    std::from_chars(port_string.data(), port_string.data() + port_string.size(), port);
  }
  return ip;
}
 
std::string NormalizeConnectionString(const std::string &connection_string, uint16_t default_port)
{
  uint16_t port = default_port;
  std::string_view ip = ParseFullConnectionString(connection_string, port);
  return std::string(ip) + ":" + std::to_string(port);
}
 
NetworkAddress ParseConnectionString(const std::string &connection_string, uint16_t default_port)
{
  uint16_t port = default_port;
  std::string_view ip = ParseFullConnectionString(connection_string, port);
  return NetworkAddress(ip, port);
}
 
/* static */ void ServerNetworkGameSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
{
  /* Register the login */
  _network_clients_connected++;
 
  ServerNetworkGameSocketHandler *cs = new ServerNetworkGameSocketHandler(s);
  cs->client_address = address; // Save the IP of the client
 
  InvalidateWindowData(WC_CLIENT_LIST, 0);
}
 
static void InitializeNetworkPools(bool close_admins = true)
{
  PoolBase::Clean(PT_NCLIENT | (close_admins ? PT_NADMIN : PT_NONE));
}
 
void NetworkClose(bool close_admins)
{
  if (_network_server) {
    if (close_admins) {
      for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::Iterate()) {
        as->CloseConnection(true);
      }
    }
 
    for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
      cs->CloseConnection(NETWORK_RECV_STATUS_CLIENT_QUIT);
    }
    ServerNetworkGameSocketHandler::CloseListeners();
    ServerNetworkAdminSocketHandler::CloseListeners();
 
    _network_coordinator_client.CloseConnection();
  } else {
    if (MyClient::my_client != nullptr) {
      MyClient::SendQuit();
      MyClient::my_client->CloseConnection(NETWORK_RECV_STATUS_CLIENT_QUIT);
    }
 
    _network_coordinator_client.CloseAllConnections();
  }
  NetworkGameSocketHandler::ProcessDeferredDeletions();
 
  TCPConnecter::KillAll();
 
  _networking = false;
  _network_server = false;
 
  NetworkFreeLocalCommandQueue();
 
  InitializeNetworkPools(close_admins);
}
 
/* Initializes the network (cleans sockets and stuff) */
static void NetworkInitialize(bool close_admins = true)
{
  InitializeNetworkPools(close_admins);
 
  _sync_frame = 0;
  _network_first_time = true;
 
  _network_reconnect = 0;
}
 
class TCPQueryConnecter : public TCPServerConnecter {
private:
  std::string connection_string;
 
public:
  TCPQueryConnecter(const std::string &connection_string) : TCPServerConnecter(connection_string, NETWORK_DEFAULT_PORT), connection_string(connection_string) {}
 
  void OnFailure() override
  {
    Debug(net, 9, "Query::OnFailure(): connection_string={}", this->connection_string);
 
    NetworkGameList *item = NetworkGameListAddItem(connection_string);
    item->status = NGLS_OFFLINE;
    item->refreshing = false;
 
    UpdateNetworkGameWindow();
  }
 
  void OnConnect(SOCKET s) override
  {
    Debug(net, 9, "Query::OnConnect(): connection_string={}", this->connection_string);
 
    QueryNetworkGameSocketHandler::QueryServer(s, this->connection_string);
  }
};
 
void NetworkQueryServer(const std::string &connection_string)
{
  if (!_network_available) return;
 
  Debug(net, 9, "NetworkQueryServer(): connection_string={}", connection_string);
 
  /* Mark the entry as refreshing, so the GUI can show the refresh is pending. */
  NetworkGameList *item = NetworkGameListAddItem(connection_string);
  item->refreshing = true;
 
  TCPConnecter::Create<TCPQueryConnecter>(connection_string);
}
 
NetworkGameList *NetworkAddServer(const std::string &connection_string, bool manually, bool never_expire)
{
  if (connection_string.empty()) return nullptr;
 
  /* Ensure the item already exists in the list */
  NetworkGameList *item = NetworkGameListAddItem(connection_string);
  if (item->info.server_name.empty()) {
    ClearGRFConfigList(&item->info.grfconfig);
    item->info.server_name = connection_string;
 
    UpdateNetworkGameWindow();
 
    NetworkQueryServer(connection_string);
  }
 
  if (manually) item->manually = true;
  if (never_expire) item->version = INT32_MAX;
 
  return item;
}
 
void GetBindAddresses(NetworkAddressList *addresses, uint16_t port)
{
  for (const auto &iter : _network_bind_list) {
    addresses->emplace_back(iter.c_str(), port);
  }
 
  /* No address, so bind to everything. */
  if (addresses->empty()) {
    addresses->emplace_back("", port);
  }
}
 
/* Generates the list of manually added hosts from NetworkGameList and
 * dumps them into the array _network_host_list. This array is needed
 * by the function that generates the config file. */
void NetworkRebuildHostList()
{
  _network_host_list.clear();
 
  for (NetworkGameList *item = _network_game_list; item != nullptr; item = item->next) {
    if (item->manually) _network_host_list.emplace_back(item->connection_string);
  }
}
 
class TCPClientConnecter : public TCPServerConnecter {
private:
  std::string connection_string;
 
public:
  TCPClientConnecter(const std::string &connection_string) : TCPServerConnecter(connection_string, NETWORK_DEFAULT_PORT), connection_string(connection_string) {}
 
  void OnFailure() override
  {
    Debug(net, 9, "Client::OnFailure(): connection_string={}", this->connection_string);
 
    ShowNetworkError(STR_NETWORK_ERROR_NOCONNECTION);
  }
 
  void OnConnect(SOCKET s) override
  {
    Debug(net, 9, "Client::OnConnect(): connection_string={}", this->connection_string);
 
    _networking = true;
    _network_own_client_id = ClientID{};
    new ClientNetworkGameSocketHandler(s, this->connection_string);
    IConsoleCmdExec("exec scripts/on_client.scr 0");
    NetworkClient_Connected();
  }
};
 
bool NetworkClientConnectGame(const std::string &connection_string, CompanyID default_company, const std::string &join_server_password)
{
  Debug(net, 9, "NetworkClientConnectGame(): connection_string={}", connection_string);
 
  CompanyID join_as = default_company;
  std::string resolved_connection_string = ServerAddress::Parse(connection_string, NETWORK_DEFAULT_PORT, &join_as).connection_string;
 
  if (!_network_available) return false;
  if (!NetworkValidateOurClientName()) return false;
 
  _network_join.connection_string = resolved_connection_string;
  _network_join.company = join_as;
  _network_join.server_password = join_server_password;
 
  if (_game_mode == GM_MENU) {
    /* From the menu we can immediately continue with the actual join. */
    NetworkClientJoinGame();
  } else {
    /* When already playing a game, first go back to the main menu. This
     * disconnects the user from the current game, meaning we can safely
     * load in the new. After all, there is little point in continueing to
     * play on a server if we are connecting to another one.
     */
    _switch_mode = SM_JOIN_GAME;
  }
  return true;
}
 
void NetworkClientJoinGame()
{
  NetworkDisconnect();
  NetworkInitialize();
 
  _settings_client.network.last_joined = _network_join.connection_string;
  Debug(net, 9, "status = CONNECTING");
  _network_join_status = NETWORK_JOIN_STATUS_CONNECTING;
  ShowJoinStatusWindow();
 
  TCPConnecter::Create<TCPClientConnecter>(_network_join.connection_string);
}
 
static void NetworkInitGameInfo()
{
  FillStaticNetworkServerGameInfo();
  /* The server is a client too */
  _network_game_info.clients_on = _network_dedicated ? 0 : 1;
 
  /* There should be always space for the server. */
  assert(NetworkClientInfo::CanAllocateItem());
  NetworkClientInfo *ci = new NetworkClientInfo(CLIENT_ID_SERVER);
  ci->client_playas = COMPANY_SPECTATOR;
 
  ci->client_name = _settings_client.network.client_name;
 
  NetworkAuthenticationClientHandler::EnsureValidSecretKeyAndUpdatePublicKey(_settings_client.network.client_secret_key, _settings_client.network.client_public_key);
  ci->public_key = _settings_client.network.client_public_key;
}
 
bool NetworkValidateServerName(std::string &server_name)
{
  StrTrimInPlace(server_name);
  if (!server_name.empty()) return true;
 
  ShowErrorMessage(STR_NETWORK_ERROR_BAD_SERVER_NAME, INVALID_STRING_ID, WL_ERROR);
  return false;
}
 
static void CheckClientAndServerName()
{
  static const std::string fallback_client_name = "Unnamed Client";
  StrTrimInPlace(_settings_client.network.client_name);
  if (_settings_client.network.client_name.empty() || _settings_client.network.client_name.compare(fallback_client_name) == 0) {
    Debug(net, 1, "No \"client_name\" has been set, using \"{}\" instead. Please set this now using the \"name <new name>\" command", fallback_client_name);
    _settings_client.network.client_name = fallback_client_name;
  }
 
  static const std::string fallback_server_name = "Unnamed Server";
  StrTrimInPlace(_settings_client.network.server_name);
  if (_settings_client.network.server_name.empty() || _settings_client.network.server_name.compare(fallback_server_name) == 0) {
    Debug(net, 1, "No \"server_name\" has been set, using \"{}\" instead. Please set this now using the \"server_name <new name>\" command", fallback_server_name);
    _settings_client.network.server_name = fallback_server_name;
  }
}
 
bool NetworkServerStart()
{
  if (!_network_available) return false;
 
  /* Call the pre-scripts */
  IConsoleCmdExec("exec scripts/pre_server.scr 0");
  if (_network_dedicated) IConsoleCmdExec("exec scripts/pre_dedicated.scr 0");
 
  /* Check for the client and server names to be set, but only after the scripts had a chance to set them.*/
  if (_network_dedicated) CheckClientAndServerName();
 
  NetworkDisconnect(false);
  NetworkInitialize(false);
  NetworkUDPInitialize();
  Debug(net, 5, "Starting listeners for clients");
  if (!ServerNetworkGameSocketHandler::Listen(_settings_client.network.server_port)) return false;
 
  /* Only listen for admins when the authentication is configured. */
  if (_settings_client.network.AdminAuthenticationConfigured()) {
    Debug(net, 5, "Starting listeners for admins");
    if (!ServerNetworkAdminSocketHandler::Listen(_settings_client.network.server_admin_port)) return false;
  }
 
  /* Try to start UDP-server */
  Debug(net, 5, "Starting listeners for incoming server queries");
  NetworkUDPServerListen();
 
  _network_server = true;
  _networking = true;
  _frame_counter = 0;
  _frame_counter_server = 0;
  _frame_counter_max = 0;
  _last_sync_frame = 0;
  _network_own_client_id = CLIENT_ID_SERVER;
 
  _network_clients_connected = 0;
 
  NetworkInitGameInfo();
 
  if (_settings_client.network.server_game_type != SERVER_GAME_TYPE_LOCAL) {
    _network_coordinator_client.Register();
  }
 
  /* execute server initialization script */
  IConsoleCmdExec("exec scripts/on_server.scr 0");
  /* if the server is dedicated ... add some other script */
  if (_network_dedicated) IConsoleCmdExec("exec scripts/on_dedicated.scr 0");
 
  return true;
}
 
void NetworkOnGameStart()
{
  if (!_network_server) return;
 
  /* Update the static game info to set the values from the new game. */
  NetworkServerUpdateGameInfo();
 
  ChangeNetworkRestartTime(true);
 
  if (!_network_dedicated) {
    Company *c = Company::GetIfValid(GetFirstPlayableCompanyID());
    NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(CLIENT_ID_SERVER);
    if (c != nullptr && ci != nullptr) {
      ci->client_playas = c->index;
 
      /*
       * If the company has not been named yet, the company was just started.
       * Otherwise it would have gotten a name already, so announce it as a new company.
       */
      if (c->name_1 == STR_SV_UNNAMED && c->name.empty()) NetworkServerNewCompany(c, ci);
    }
 
    ShowClientList();
  } else {
    /* welcome possibly still connected admins - this can only happen on a dedicated server. */
    ServerNetworkAdminSocketHandler::WelcomeAll();
  }
}
 
/* The server is rebooting...
 * The only difference with NetworkDisconnect, is the packets that is sent */
void NetworkReboot()
{
  if (_network_server) {
    for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
      cs->SendNewGame();
      cs->SendPackets();
    }
 
    for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
      as->SendNewGame();
      as->SendPackets();
    }
  }
 
  /* For non-dedicated servers we have to kick the admins as we are not
   * certain that we will end up in a new network game. */
  NetworkClose(!_network_dedicated);
}
 
void NetworkDisconnect(bool close_admins)
{
  if (_network_server) {
    for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
      cs->SendShutdown();
      cs->SendPackets();
    }
 
    if (close_admins) {
      for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
        as->SendShutdown();
        as->SendPackets();
      }
    }
  }
 
  CloseWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
 
  NetworkClose(close_admins);
 
  /* Reinitialize the UDP stack, i.e. close all existing connections. */
  NetworkUDPInitialize();
}
 
void NetworkUpdateServerGameType()
{
  if (!_networking) return;
 
  switch (_settings_client.network.server_game_type) {
    case SERVER_GAME_TYPE_LOCAL:
      _network_coordinator_client.CloseConnection();
      break;
 
    case SERVER_GAME_TYPE_INVITE_ONLY:
    case SERVER_GAME_TYPE_PUBLIC:
      _network_coordinator_client.Register();
      break;
 
    default:
      NOT_REACHED();
  }
}
 
static bool NetworkReceive()
{
  bool result;
  if (_network_server) {
    ServerNetworkAdminSocketHandler::Receive();
    result = ServerNetworkGameSocketHandler::Receive();
  } else {
    result = ClientNetworkGameSocketHandler::Receive();
  }
  NetworkGameSocketHandler::ProcessDeferredDeletions();
  return result;
}
 
/* This sends all buffered commands (if possible) */
static void NetworkSend()
{
  if (_network_server) {
    ServerNetworkAdminSocketHandler::Send();
    ServerNetworkGameSocketHandler::Send();
  } else {
    ClientNetworkGameSocketHandler::Send();
  }
  NetworkGameSocketHandler::ProcessDeferredDeletions();
}
 
void NetworkBackgroundLoop()
{
  _network_content_client.SendReceive();
  _network_coordinator_client.SendReceive();
  TCPConnecter::CheckCallbacks();
  NetworkHTTPSocketHandler::HTTPReceive();
  QueryNetworkGameSocketHandler::SendReceive();
  NetworkGameSocketHandler::ProcessDeferredDeletions();
 
  NetworkBackgroundUDPLoop();
}
 
/* The main loop called from ttd.c
 *  Here we also have to do StateGameLoop if needed! */
void NetworkGameLoop()
{
  if (!_networking) return;
 
  if (!NetworkReceive()) return;
 
  if (_network_server) {
    /* Log the sync state to check for in-syncedness of replays. */
    if (TimerGameEconomy::date_fract == 0) {
      /* We don't want to log multiple times if paused. */
      static TimerGameEconomy::Date last_log;
      if (last_log != TimerGameEconomy::date) {
        Debug(desync, 1, "sync: {:08x}; {:02x}; {:08x}; {:08x}", TimerGameEconomy::date, TimerGameEconomy::date_fract, _random.state[0], _random.state[1]);
        last_log = TimerGameEconomy::date;
      }
    }
 
#ifdef DEBUG_DUMP_COMMANDS
    /* Loading of the debug commands from -ddesync>=1 */
    static auto f = FioFOpenFile("commands.log", "rb", SAVE_DIR);
    static TimerGameEconomy::Date next_date(0);
    static uint32_t next_date_fract;
    static CommandPacket *cp = nullptr;
    static bool check_sync_state = false;
    static uint32_t sync_state[2];
    if (!f.has_value() && next_date == 0) {
      Debug(desync, 0, "Cannot open commands.log");
      next_date = TimerGameEconomy::Date(1);
    }
 
    while (f.has_value() && !feof(*f)) {
      if (TimerGameEconomy::date == next_date && TimerGameEconomy::date_fract == next_date_fract) {
        if (cp != nullptr) {
          NetworkSendCommand(cp->cmd, cp->err_msg, nullptr, cp->company, cp->data);
          Debug(desync, 0, "Injecting: {:08x}; {:02x}; {:02x}; {:08x}; {} ({})", TimerGameEconomy::date, TimerGameEconomy::date_fract, (int)_current_company, cp->cmd, FormatArrayAsHex(cp->data), GetCommandName(cp->cmd));
          delete cp;
          cp = nullptr;
        }
        if (check_sync_state) {
          if (sync_state[0] == _random.state[0] && sync_state[1] == _random.state[1]) {
            Debug(desync, 0, "Sync check: {:08x}; {:02x}; match", TimerGameEconomy::date, TimerGameEconomy::date_fract);
          } else {
            Debug(desync, 0, "Sync check: {:08x}; {:02x}; mismatch expected {{{:08x}, {:08x}}}, got {{{:08x}, {:08x}}}",
                  TimerGameEconomy::date, TimerGameEconomy::date_fract, sync_state[0], sync_state[1], _random.state[0], _random.state[1]);
            NOT_REACHED();
          }
          check_sync_state = false;
        }
      }
 
      /* Skip all entries in the command-log till we caught up with the current game again. */
      if (TimerGameEconomy::date > next_date || (TimerGameEconomy::date == next_date && TimerGameEconomy::date_fract > next_date_fract)) {
        Debug(desync, 0, "Skipping to next command at {:08x}:{:02x}", next_date, next_date_fract);
        if (cp != nullptr) {
          delete cp;
          cp = nullptr;
        }
        check_sync_state = false;
      }
 
      if (cp != nullptr || check_sync_state) break;
 
      char buff[4096];
      if (fgets(buff, lengthof(buff), *f) == nullptr) break;
 
      char *p = buff;
      /* Ignore the "[date time] " part of the message */
      if (*p == '[') {
        p = strchr(p, ']');
        if (p == nullptr) break;
        p += 2;
      }
 
      if (strncmp(p, "cmd: ", 5) == 0
#ifdef DEBUG_FAILED_DUMP_COMMANDS
        || strncmp(p, "cmdf: ", 6) == 0
#endif
        ) {
        p += 5;
        if (*p == ' ') p++;
        cp = new CommandPacket();
        int company;
        uint cmd;
        char buffer[256];
        uint32_t next_date_raw;
        int ret = sscanf(p, "%x; %x; %x; %x; %x; %255s", &next_date_raw, &next_date_fract, &company, &cmd, &cp->err_msg, buffer);
        assert(ret == 6);
        next_date = TimerGameEconomy::Date((int32_t)next_date_raw);
        cp->company = (CompanyID)company;
        cp->cmd = (Commands)cmd;
 
        /* Parse command data. */
        std::vector<uint8_t> args;
        size_t arg_len = strlen(buffer);
        for (size_t i = 0; i + 1 < arg_len; i += 2) {
          uint8_t e = 0;
          std::from_chars(buffer + i, buffer + i + 2, e, 16);
          args.emplace_back(e);
        }
        cp->data = args;
      } else if (strncmp(p, "join: ", 6) == 0) {
        /* Manually insert a pause when joining; this way the client can join at the exact right time. */
        uint32_t next_date_raw;
        int ret = sscanf(p + 6, "%x; %x", &next_date_raw, &next_date_fract);
        next_date = TimerGameEconomy::Date((int32_t)next_date_raw);
        assert(ret == 2);
        Debug(desync, 0, "Injecting pause for join at {:08x}:{:02x}; please join when paused", next_date, next_date_fract);
        cp = new CommandPacket();
        cp->company = COMPANY_SPECTATOR;
        cp->cmd = CMD_PAUSE;
        cp->data = EndianBufferWriter<>::FromValue(CommandTraits<CMD_PAUSE>::Args{ PM_PAUSED_NORMAL, true });
        _ddc_fastforward = false;
      } else if (strncmp(p, "sync: ", 6) == 0) {
        uint32_t next_date_raw;
        int ret = sscanf(p + 6, "%x; %x; %x; %x", &next_date_raw, &next_date_fract, &sync_state[0], &sync_state[1]);
        next_date = TimerGameEconomy::Date((int32_t)next_date_raw);
        assert(ret == 4);
        check_sync_state = true;
      } else if (strncmp(p, "msg: ", 5) == 0 || strncmp(p, "client: ", 8) == 0 ||
            strncmp(p, "load: ", 6) == 0 || strncmp(p, "save: ", 6) == 0 ||
            strncmp(p, "warning: ", 9) == 0) {
        /* A message that is not very important to the log playback, but part of the log. */
#ifndef DEBUG_FAILED_DUMP_COMMANDS
      } else if (strncmp(p, "cmdf: ", 6) == 0) {
        Debug(desync, 0, "Skipping replay of failed command: {}", p + 6);
#endif
      } else {
        /* Can't parse a line; what's wrong here? */
        Debug(desync, 0, "Trying to parse: {}", p);
        NOT_REACHED();
      }
    }
    if (f.has_value() && feof(*f)) {
      Debug(desync, 0, "End of commands.log");
      f.reset();
    }
#endif /* DEBUG_DUMP_COMMANDS */
    if (_frame_counter >= _frame_counter_max) {
      /* Only check for active clients just before we're going to send out
       * the commands so we don't send multiple pause/unpause commands when
       * the frame_freq is more than 1 tick. Same with distributing commands. */
      CheckPauseOnJoin();
      CheckMinActiveClients();
      NetworkDistributeCommands();
    }
 
    bool send_frame = false;
 
    /* We first increase the _frame_counter */
    _frame_counter++;
    /* Update max-frame-counter */
    if (_frame_counter > _frame_counter_max) {
      _frame_counter_max = _frame_counter + _settings_client.network.frame_freq;
      send_frame = true;
    }
 
    NetworkExecuteLocalCommandQueue();
 
    /* Then we make the frame */
    StateGameLoop();
 
    _sync_seed_1 = _random.state[0];
#ifdef NETWORK_SEND_DOUBLE_SEED
    _sync_seed_2 = _random.state[1];
#endif
 
    NetworkServer_Tick(send_frame);
  } else {
    /* Client */
 
    /* Make sure we are at the frame were the server is (quick-frames) */
    if (_frame_counter_server > _frame_counter) {
      /* Run a number of frames; when things go bad, get out. */
      while (_frame_counter_server > _frame_counter) {
        if (!ClientNetworkGameSocketHandler::GameLoop()) return;
      }
    } else {
      /* Else, keep on going till _frame_counter_max */
      if (_frame_counter_max > _frame_counter) {
        /* Run one frame; if things went bad, get out. */
        if (!ClientNetworkGameSocketHandler::GameLoop()) return;
      }
    }
  }
 
  NetworkSend();
}
 
void NetworkStartUp()
{
  Debug(net, 3, "Starting network");
 
  /* Network is available */
  _network_available = NetworkCoreInitialize();
  _network_dedicated = false;
 
  _network_game_info = {};
 
  NetworkInitialize();
  NetworkUDPInitialize();
  Debug(net, 3, "Network online, multiplayer available");
  NetworkFindBroadcastIPs(&_broadcast_list);
  NetworkHTTPInitialize();
}
 
void NetworkShutDown()
{
  NetworkDisconnect();
  NetworkHTTPUninitialize();
  NetworkUDPClose();
 
  Debug(net, 3, "Shutting down network");
 
  _network_available = false;
 
  NetworkCoreShutdown();
}
 
#ifdef __EMSCRIPTEN__
extern "C" {
 
void CDECL em_openttd_add_server(const char *connection_string)
{
  NetworkAddServer(connection_string, false, true);
}
 
}
#endif