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 "../date_func.h"
#include "network_admin.h"
#include "network_client.h"
#include "network_server.h"
#include "network_content.h"
#include "network_udp.h"
#include "network_gamelist.h"
#include "network_base.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 "../safeguards.h"
 
#ifdef DEBUG_DUMP_COMMANDS
#include "../fileio_func.h"
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;  
NetworkServerGameInfo _network_game_info; 
NetworkCompanyState *_network_company_states = nullptr; 
ClientID _network_own_client_id;      
ClientID _redirect_console_to_client; 
bool _network_need_advertise;         
uint8 _network_reconnect;             
StringList _network_bind_list;        
StringList _network_host_list;        
StringList _network_ban_list;         
uint32 _frame_counter_server;         
uint32 _frame_counter_max;            
uint32 _frame_counter;                
uint32 _last_sync_frame;              
NetworkAddressList _broadcast_list;   
uint32 _sync_seed_1;                  
#ifdef NETWORK_SEND_DOUBLE_SEED
uint32 _sync_seed_2;                  
#endif
uint32 _sync_frame;                   
bool _network_first_time;             
CompanyMask _network_company_passworded; 
 
/* Check whether NETWORK_NUM_LANDSCAPES is still in sync with NUM_LANDSCAPE */
static_assert((int)NETWORK_NUM_LANDSCAPES == (int)NUM_LANDSCAPE);
static_assert((int)NETWORK_COMPANY_NAME_LENGTH == MAX_LENGTH_COMPANY_NAME_CHARS * MAX_CHAR_LENGTH);
 
byte _network_clients_connected = 0;
 
/* Some externs / forwards */
extern void StateGameLoop();
 
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;
}
 
/* static */ ServerNetworkGameSocketHandler *ServerNetworkGameSocketHandler::GetByClientID(ClientID client_id)
{
  for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
    if (cs->client_id == client_id) return cs;
  }
 
  return nullptr;
}
 
byte NetworkSpectatorCount()
{
  byte 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;
}
 
const char *NetworkChangeCompanyPassword(CompanyID company_id, const char *password)
{
  if (strcmp(password, "*") == 0) password = "";
 
  if (_network_server) {
    NetworkServerSetCompanyPassword(company_id, password, false);
  } else {
    NetworkClientSetCompanyPassword(password);
  }
 
  return password;
}
 
const char *GenerateCompanyPasswordHash(const char *password, const char *password_server_id, uint32 password_game_seed)
{
  if (StrEmpty(password)) return password;
 
  char salted_password[NETWORK_SERVER_ID_LENGTH];
 
  memset(salted_password, 0, sizeof(salted_password));
  seprintf(salted_password, lastof(salted_password), "%s", password);
  /* Add the game seed and the server's ID as the salt. */
  for (uint i = 0; i < NETWORK_SERVER_ID_LENGTH - 1; i++) {
    salted_password[i] ^= password_server_id[i] ^ (password_game_seed >> (i % 32));
  }
 
  Md5 checksum;
  uint8 digest[16];
  static char hashed_password[NETWORK_SERVER_ID_LENGTH];
 
  /* Generate the MD5 hash */
  checksum.Append(salted_password, sizeof(salted_password) - 1);
  checksum.Finish(digest);
 
  for (int di = 0; di < 16; di++) seprintf(hashed_password + di * 2, lastof(hashed_password), "%02x", digest[di]);
 
  return hashed_password;
}
 
bool NetworkCompanyIsPassworded(CompanyID company_id)
{
  return HasBit(_network_company_passworded, company_id);
}
 
/* 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 char *name, const char *str, int64 data)
{
  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;
    default:                            strid = STR_NETWORK_CHAT_ALL; break;
  }
 
  char message[1024];
  SetDParamStr(0, name);
  SetDParamStr(1, str);
  SetDParam(2, data);
 
  /* 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. */
  char *msg_ptr = message + Utf8Encode(message, _current_text_dir == TD_LTR ? CHAR_TD_LRM : CHAR_TD_RLM);
  GetString(msg_ptr, strid, lastof(message));
 
  DEBUG(desync, 1, "msg: %08x; %02x; %s", _date, _date_fract, message);
  IConsolePrintF(colour, "%s", message);
  NetworkAddChatMessage((TextColour)colour, _settings_client.gui.network_chat_timeout, "%s", 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 his ACK packet after 1 DAY_TICKS..
   *  so we increase his lag for every frame that passes!
   * The packet can be out by a max of _net_frame_freq */
  if (cs->last_frame_server + DAY_TICKS + _settings_client.network.frame_freq < _frame_counter) {
    lag += _frame_counter - (cs->last_frame_server + 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 NetworkError(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,
  };
  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;
      }
 
      char buffer[DRAW_STRING_BUFFER];
      GetString(buffer, str, lastof(buffer));
      NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE, CC_DEFAULT, false, nullptr, buffer);
      break;
    }
 
    default:
      return;
  }
}
 
 
static void CheckPauseHelper(bool pause, PauseMode pm)
{
  if (pause == ((_pause_mode & pm) != PM_UNPAUSED)) return;
 
  DoCommandP(0, pm, pause ? 1 : 0, CMD_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);
}
 
void ParseConnectionString(const char **company, const char **port, char *connection_string)
{
  bool ipv6 = (strchr(connection_string, ':') != strrchr(connection_string, ':'));
  char *p;
  for (p = connection_string; *p != '\0'; p++) {
    switch (*p) {
      case '[':
        ipv6 = true;
        break;
 
      case ']':
        ipv6 = false;
        break;
 
      case '#':
        *company = p + 1;
        *p = '\0';
        break;
 
      case ':':
        if (ipv6) break;
        *port = p + 1;
        *p = '\0';
        break;
    }
  }
}
 
/* static */ void ServerNetworkGameSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
{
  /* Register the login */
  _network_clients_connected++;
 
  SetWindowDirty(WC_CLIENT_LIST, 0);
  ServerNetworkGameSocketHandler *cs = new ServerNetworkGameSocketHandler(s);
  cs->client_address = address; // Save the IP of the client
}
 
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_CONN_LOST);
    }
    ServerNetworkGameSocketHandler::CloseListeners();
    ServerNetworkAdminSocketHandler::CloseListeners();
  } else if (MyClient::my_client != nullptr) {
    MyClient::SendQuit();
    MyClient::my_client->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
  }
 
  TCPConnecter::KillAll();
 
  _networking = false;
  _network_server = false;
 
  NetworkFreeLocalCommandQueue();
 
  free(_network_company_states);
  _network_company_states = nullptr;
 
  InitializeNetworkPools(close_admins);
}
 
/* Initializes the network (cleans sockets and stuff) */
static void NetworkInitialize(bool close_admins = true)
{
  InitializeNetworkPools(close_admins);
  NetworkUDPInitialize();
 
  _sync_frame = 0;
  _network_first_time = true;
 
  _network_reconnect = 0;
}
 
class TCPQueryConnecter : TCPConnecter {
public:
  TCPQueryConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
 
  void OnFailure() override
  {
    NetworkDisconnect();
  }
 
  void OnConnect(SOCKET s) override
  {
    _networking = true;
    new ClientNetworkGameSocketHandler(s);
    MyClient::SendCompanyInformationQuery();
  }
};
 
/* Query a server to fetch his game-info
 *  If game_info is true, only the gameinfo is fetched,
 *   else only the client_info is fetched */
void NetworkTCPQueryServer(NetworkAddress address)
{
  if (!_network_available) return;
 
  NetworkDisconnect();
  NetworkInitialize();
 
  new TCPQueryConnecter(address);
}
 
/* Validates an address entered as a string and adds the server to
 * the list. If you use this function, the games will be marked
 * as manually added. */
void NetworkAddServer(const char *b)
{
  if (*b != '\0') {
    const char *port = nullptr;
    const char *company = nullptr;
    char host[NETWORK_HOSTNAME_LENGTH];
    uint16 rport;
 
    strecpy(host, b, lastof(host));
 
    strecpy(_settings_client.network.connect_to_ip, b, lastof(_settings_client.network.connect_to_ip));
    rport = NETWORK_DEFAULT_PORT;
 
    ParseConnectionString(&company, &port, host);
    if (port != nullptr) rport = atoi(port);
 
    NetworkUDPQueryServer(NetworkAddress(host, rport), true);
  }
}
 
void GetBindAddresses(NetworkAddressList *addresses, uint16 port)
{
  for (const auto &iter : _network_bind_list) {
    addresses->emplace_back(iter.c_str(), port);
  }
 
  /* No address, so bind to everything. */
  if (addresses->size() == 0) {
    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->address.GetAddressAsString(false));
  }
}
 
class TCPClientConnecter : TCPConnecter {
public:
  TCPClientConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
 
  void OnFailure() override
  {
    NetworkError(STR_NETWORK_ERROR_NOCONNECTION);
  }
 
  void OnConnect(SOCKET s) override
  {
    _networking = true;
    new ClientNetworkGameSocketHandler(s);
    IConsoleCmdExec("exec scripts/on_client.scr 0");
    NetworkClient_Connected();
  }
};
 
 
/* Used by clients, to connect to a server */
void NetworkClientConnectGame(NetworkAddress address, CompanyID join_as, const char *join_server_password, const char *join_company_password)
{
  if (!_network_available) return;
 
  if (address.GetPort() == 0) return;
 
  strecpy(_settings_client.network.last_host, address.GetHostname(), lastof(_settings_client.network.last_host));
  _settings_client.network.last_port = address.GetPort();
  _network_join_as = join_as;
  _network_join_server_password = join_server_password;
  _network_join_company_password = join_company_password;
 
  NetworkDisconnect();
  NetworkInitialize();
 
  _network_join_status = NETWORK_JOIN_STATUS_CONNECTING;
  ShowJoinStatusWindow();
 
  new TCPClientConnecter(address);
}
 
static void NetworkInitGameInfo()
{
  if (StrEmpty(_settings_client.network.server_name)) {
    seprintf(_settings_client.network.server_name, lastof(_settings_client.network.server_name), "Unnamed Server");
  }
 
  /* 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 = _network_dedicated ? COMPANY_SPECTATOR : COMPANY_FIRST;
 
  strecpy(ci->client_name, _settings_client.network.client_name, lastof(ci->client_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");
 
  NetworkDisconnect(false, false);
  NetworkInitialize(false);
  DEBUG(net, 1, "starting listeners for clients");
  if (!ServerNetworkGameSocketHandler::Listen(_settings_client.network.server_port)) return false;
 
  /* Only listen for admins when the password isn't empty. */
  if (!StrEmpty(_settings_client.network.admin_password)) {
    DEBUG(net, 1, "starting listeners for admins");
    if (!ServerNetworkAdminSocketHandler::Listen(_settings_client.network.server_admin_port)) return false;
  }
 
  /* Try to start UDP-server */
  DEBUG(net, 1, "starting listeners for incoming server queries");
  NetworkUDPServerListen();
 
  _network_company_states = CallocT<NetworkCompanyState>(MAX_COMPANIES);
  _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;
  _network_company_passworded = 0;
 
  NetworkInitGameInfo();
 
  /* 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");
 
  /* Try to register us to the master server */
  _network_need_advertise = true;
  NetworkUDPAdvertise();
 
  /* welcome possibly still connected admins - this can only happen on a dedicated server. */
  if (_network_dedicated) ServerNetworkAdminSocketHandler::WelcomeAll();
 
  return true;
}
 
/* 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 blocking, 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();
      }
    }
  }
 
  if (_settings_client.network.server_advertise) NetworkUDPRemoveAdvertise(blocking);
 
  DeleteWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
 
  NetworkClose(close_admins);
 
  /* Reinitialize the UDP stack, i.e. close all existing connections. */
  NetworkUDPInitialize();
}
 
static bool NetworkReceive()
{
  if (_network_server) {
    ServerNetworkAdminSocketHandler::Receive();
    return ServerNetworkGameSocketHandler::Receive();
  } else {
    return ClientNetworkGameSocketHandler::Receive();
  }
}
 
/* This sends all buffered commands (if possible) */
static void NetworkSend()
{
  if (_network_server) {
    ServerNetworkAdminSocketHandler::Send();
    ServerNetworkGameSocketHandler::Send();
  } else {
    ClientNetworkGameSocketHandler::Send();
  }
}
 
void NetworkBackgroundLoop()
{
  _network_content_client.SendReceive();
  TCPConnecter::CheckCallbacks();
  NetworkHTTPSocketHandler::HTTPReceive();
 
  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 (_date_fract == 0) {
      /* We don't want to log multiple times if paused. */
      static Date last_log;
      if (last_log != _date) {
        DEBUG(desync, 1, "sync: %08x; %02x; %08x; %08x", _date, _date_fract, _random.state[0], _random.state[1]);
        last_log = _date;
      }
    }
 
#ifdef DEBUG_DUMP_COMMANDS
    /* Loading of the debug commands from -ddesync>=1 */
    static FILE *f = FioFOpenFile("commands.log", "rb", SAVE_DIR);
    static Date next_date = 0;
    static uint32 next_date_fract;
    static CommandPacket *cp = nullptr;
    static bool check_sync_state = false;
    static uint32 sync_state[2];
    if (f == nullptr && next_date == 0) {
      DEBUG(net, 0, "Cannot open commands.log");
      next_date = 1;
    }
 
    while (f != nullptr && !feof(f)) {
      if (_date == next_date && _date_fract == next_date_fract) {
        if (cp != nullptr) {
          NetworkSendCommand(cp->tile, cp->p1, cp->p2, cp->cmd & ~CMD_FLAGS_MASK, nullptr, cp->text, cp->company);
          DEBUG(net, 0, "injecting: %08x; %02x; %02x; %06x; %08x; %08x; %08x; \"%s\" (%s)", _date, _date_fract, (int)_current_company, cp->tile, cp->p1, cp->p2, cp->cmd, cp->text, GetCommandName(cp->cmd));
          free(cp);
          cp = nullptr;
        }
        if (check_sync_state) {
          if (sync_state[0] == _random.state[0] && sync_state[1] == _random.state[1]) {
            DEBUG(net, 0, "sync check: %08x; %02x; match", _date, _date_fract);
          } else {
            DEBUG(net, 0, "sync check: %08x; %02x; mismatch expected {%08x, %08x}, got {%08x, %08x}",
                  _date, _date_fract, sync_state[0], sync_state[1], _random.state[0], _random.state[1]);
            NOT_REACHED();
          }
          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 = CallocT<CommandPacket>(1);
        int company;
        static_assert(sizeof(cp->text) == 128);
        int ret = sscanf(p, "%x; %x; %x; %x; %x; %x; %x; \"%127[^\"]\"", &next_date, &next_date_fract, &company, &cp->tile, &cp->p1, &cp->p2, &cp->cmd, cp->text);
        /* There are 8 pieces of data to read, however the last is a
         * string that might or might not exist. Ignore it if that
         * string misses because in 99% of the time it's not used. */
        assert(ret == 8 || ret == 7);
        cp->company = (CompanyID)company;
      } else if (strncmp(p, "join: ", 6) == 0) {
        /* Manually insert a pause when joining; this way the client can join at the exact right time. */
        int ret = sscanf(p + 6, "%x; %x", &next_date, &next_date_fract);
        assert(ret == 2);
        DEBUG(net, 0, "injecting pause for join at %08x:%02x; please join when paused", next_date, next_date_fract);
        cp = CallocT<CommandPacket>(1);
        cp->company = COMPANY_SPECTATOR;
        cp->cmd = CMD_PAUSE;
        cp->p1 = PM_PAUSED_NORMAL;
        cp->p2 = 1;
        _ddc_fastforward = false;
      } else if (strncmp(p, "sync: ", 6) == 0) {
        int ret = sscanf(p + 6, "%x; %x; %x; %x", &next_date, &next_date_fract, &sync_state[0], &sync_state[1]);
        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) {
        /* 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(net, 0, "Skipping replay of failed command: %s", p + 6);
#endif
      } else {
        /* Can't parse a line; what's wrong here? */
        DEBUG(net, 0, "trying to parse: %s", p);
        NOT_REACHED();
      }
    }
    if (f != nullptr && feof(f)) {
      DEBUG(net, 0, "End of commands.log");
      fclose(f);
      f = nullptr;
    }
#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();
}
 
static void NetworkGenerateServerId()
{
  Md5 checksum;
  uint8 digest[16];
  char hex_output[16 * 2 + 1];
  char coding_string[NETWORK_NAME_LENGTH];
  int di;
 
  seprintf(coding_string, lastof(coding_string), "%d%s", (uint)Random(), "OpenTTD Server ID");
 
  /* Generate the MD5 hash */
  checksum.Append((const uint8*)coding_string, strlen(coding_string));
  checksum.Finish(digest);
 
  for (di = 0; di < 16; ++di) {
    seprintf(hex_output + di * 2, lastof(hex_output), "%02x", digest[di]);
  }
 
  /* _settings_client.network.network_id is our id */
  seprintf(_settings_client.network.network_id, lastof(_settings_client.network.network_id), "%s", hex_output);
}
 
void NetworkStartDebugLog(NetworkAddress address)
{
  extern SOCKET _debug_socket;  // Comes from debug.c
 
  DEBUG(net, 0, "Redirecting DEBUG() to %s:%d", address.GetHostname(), address.GetPort());
 
  SOCKET s = address.Connect();
  if (s == INVALID_SOCKET) {
    DEBUG(net, 0, "Failed to open socket for redirection DEBUG()");
    return;
  }
 
  _debug_socket = s;
 
  DEBUG(net, 0, "DEBUG() is now redirected");
}
 
void NetworkStartUp()
{
  DEBUG(net, 3, "[core] starting network...");
 
  /* Network is available */
  _network_available = NetworkCoreInitialize();
  _network_dedicated = false;
  _network_need_advertise = true;
 
  /* Generate an server id when there is none yet */
  if (StrEmpty(_settings_client.network.network_id)) NetworkGenerateServerId();
 
  memset(&_network_game_info, 0, sizeof(_network_game_info));
 
  NetworkInitialize();
  DEBUG(net, 3, "[core] network online, multiplayer available");
  NetworkFindBroadcastIPs(&_broadcast_list);
}
 
void NetworkShutDown()
{
  NetworkDisconnect(true);
  NetworkUDPClose();
 
  DEBUG(net, 3, "[core] shutting down network");
 
  _network_available = false;
 
  NetworkCoreShutdown();
}
 
static const uint GITHASH_SUFFIX_LEN = 12;
 
const char * GetNetworkRevisionString()
{
  /* This will be allocated on heap and never free'd, but only once so not a "real" leak. */
  static char *network_revision = nullptr;
 
  if (!network_revision) {
    /* Start by taking a chance on the full revision string. */
    network_revision = stredup(_openttd_revision);
    /* Ensure it's not longer than the packet buffer length. */
    if (strlen(network_revision) >= NETWORK_REVISION_LENGTH) network_revision[NETWORK_REVISION_LENGTH - 1] = '\0';
 
    /* Tag names are not mangled further. */
    if (_openttd_revision_tagged) {
      DEBUG(net, 1, "Network revision name is '%s'", network_revision);
      return network_revision;
    }
 
    /* Prepare a prefix of the git hash.
    * Size is length + 1 for terminator, +2 for -g prefix. */
    assert(_openttd_revision_modified < 3);
    char githash_suffix[GITHASH_SUFFIX_LEN + 1] = "-";
    githash_suffix[1] = "gum"[_openttd_revision_modified];
    for (uint i = 2; i < GITHASH_SUFFIX_LEN; i++) {
      githash_suffix[i] = _openttd_revision_hash[i-2];
    }
 
    /* Where did the hash start in the original string?
     * Overwrite from that position, unless that would go past end of packet buffer length. */
    ptrdiff_t hashofs = strrchr(_openttd_revision, '-') - _openttd_revision;
    if (hashofs + strlen(githash_suffix) + 1 > NETWORK_REVISION_LENGTH) hashofs = strlen(network_revision) - strlen(githash_suffix);
    /* Replace the git hash in revision string. */
    strecpy(network_revision + hashofs, githash_suffix, network_revision + NETWORK_REVISION_LENGTH);
    assert(strlen(network_revision) < NETWORK_REVISION_LENGTH); // strlen does not include terminator, constant does, hence strictly less than
    DEBUG(net, 1, "Network revision name is '%s'", network_revision);
  }
 
  return network_revision;
}
 
static const char *ExtractNetworkRevisionHash(const char *revstr)
{
  return strrchr(revstr, '-');
}
 
bool IsNetworkCompatibleVersion(const char *other)
{
  if (strncmp(GetNetworkRevisionString(), other, NETWORK_REVISION_LENGTH - 1) == 0) return true;
 
  /* If this version is tagged, then the revision string must be a complete match,
   * since there is no git hash suffix in it.
   * This is needed to avoid situations like "1.9.0-beta1" comparing equal to "2.0.0-beta1".  */
  if (_openttd_revision_tagged) return false;
 
  const char *hash1 = ExtractNetworkRevisionHash(GetNetworkRevisionString());
  const char *hash2 = ExtractNetworkRevisionHash(other);
  return hash1 && hash2 && (strncmp(hash1, hash2, GITHASH_SUFFIX_LEN) == 0);
}
 
#ifdef __EMSCRIPTEN__
extern "C" {
 
void CDECL em_openttd_add_server(const char *host, int port)
{
  NetworkUDPQueryServer(NetworkAddress(host, port), true);
}
 
}
#endif