network_admin.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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#include "../stdafx.h"
 
#include "../strings_func.h"
#include "../timer/timer_game_calendar.h"
#include "../timer/timer_game_calendar.h"
#include "core/network_game_info.h"
#include "network_admin.h"
#include "network_base.h"
#include "network_server.h"
#include "../command_func.h"
#include "../company_base.h"
#include "../console_func.h"
#include "../core/pool_func.hpp"
#include "../map_func.h"
#include "../rev.h"
#include "../game/game.hpp"
#include "../script/api/script_event_types.hpp"
 
#include "table/strings.h"
 
#include "../safeguards.h"
 
 
/* This file handles all the admin network commands. */

AdminID _redirect_console_to_admin = AdminID::Invalid();

NetworkAdminSocketPool _networkadminsocket_pool("NetworkAdminSocket");
INSTANTIATE_POOL_METHODS(NetworkAdminSocket)
 
static NetworkAuthenticationDefaultPasswordProvider _admin_password_provider{_settings_client.network.admin_password}; 
static NetworkAuthenticationDefaultAuthorizedKeyHandler _admin_authorized_key_handler{_settings_client.network.admin_authorized_keys}; 

static const std::chrono::seconds ADMIN_AUTHORISATION_TIMEOUT{10};
 

static const EnumIndexArray<AdminUpdateFrequencies, AdminUpdateType, AdminUpdateType::End> _admin_update_type_frequencies{{{
  {AdminUpdateFrequency::Poll, AdminUpdateFrequency::Daily, AdminUpdateFrequency::Weekly, AdminUpdateFrequency::Monthly, AdminUpdateFrequency::Quarterly, AdminUpdateFrequency::Annually}, // AdminUpdateType::Date
  {AdminUpdateFrequency::Poll, AdminUpdateFrequency::Automatic,                                                                                                                         }, // AdminUpdateType::ClientInfo
  {AdminUpdateFrequency::Poll, AdminUpdateFrequency::Automatic,                                                                                                                         }, // AdminUpdateType::CompanyInfo
  {AdminUpdateFrequency::Poll,                              AdminUpdateFrequency::Weekly, AdminUpdateFrequency::Monthly, AdminUpdateFrequency::Quarterly, AdminUpdateFrequency::Annually}, // AdminUpdateType::CompanyEconomy
  {AdminUpdateFrequency::Poll,                              AdminUpdateFrequency::Weekly, AdminUpdateFrequency::Monthly, AdminUpdateFrequency::Quarterly, AdminUpdateFrequency::Annually}, // AdminUpdateType::CompanyStats
  {                            AdminUpdateFrequency::Automatic,                                                                                                                         }, // AdminUpdateType::Chat
  {                            AdminUpdateFrequency::Automatic,                                                                                                                         }, // AdminUpdateType::Console
  {AdminUpdateFrequency::Poll,                                                                                                                                                          }, // AdminUpdateType::CmdNames
  {                            AdminUpdateFrequency::Automatic,                                                                                                                         }, // AdminUpdateType::CmdLogging
  {                            AdminUpdateFrequency::Automatic,                                                                                                                         }, // AdminUpdateType::Gamescript
}}};

ServerNetworkAdminSocketHandler::ServerNetworkAdminSocketHandler(AdminID index, SOCKET s) :
  NetworkAdminSocketPool::PoolItem<&_networkadminsocket_pool>(index), NetworkAdminSocketHandler(s)
{
  this->status = AdminStatus::Inactive;
  this->connect_time = std::chrono::steady_clock::now();
}

ServerNetworkAdminSocketHandler::~ServerNetworkAdminSocketHandler()
{
  Debug(net, 3, "[admin] '{}' ({}) has disconnected", this->admin_name, this->admin_version);
  if (_redirect_console_to_admin == this->index) _redirect_console_to_admin = AdminID::Invalid();
 
  if (this->update_frequency[AdminUpdateType::Console].Test(AdminUpdateFrequency::Automatic)) {
    this->update_frequency[AdminUpdateType::Console] = {};
    DebugReconsiderSendRemoteMessages();
  }
}

/* static */ bool ServerNetworkAdminSocketHandler::AllowConnection()
{
  return _settings_client.network.AdminAuthenticationConfigured() && ServerNetworkAdminSocketHandler::CanAllocateItem();
}

/* static */ void ServerNetworkAdminSocketHandler::Send()
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::Iterate()) {
    if (as->status <= AdminStatus::Authenticate && std::chrono::steady_clock::now() > as->connect_time + ADMIN_AUTHORISATION_TIMEOUT) {
      Debug(net, 2, "[admin] Admin did not send its authorisation within {} seconds", std::chrono::duration_cast<std::chrono::seconds>(ADMIN_AUTHORISATION_TIMEOUT).count());
      as->CloseConnection(true);
      continue;
    }
    if (as->writable) {
      as->SendPackets();
    }
  }
}

/* static */ void ServerNetworkAdminSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
{
  ServerNetworkAdminSocketHandler *as = ServerNetworkAdminSocketHandler::Create(s);
  as->address = address; // Save the IP of the client
}
 
/***********
 * Sending functions for admin network
 ************/

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendError(NetworkErrorCode error)
{
  /* Whatever the error might be, authentication (keys) must be released as soon as possible. */
  this->authentication_handler = nullptr;
 
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerError);
 
  p->Send_uint8(to_underlying(error));
  this->SendPacket(std::move(p));
 
  std::string error_message = GetString(GetNetworkErrorMsg(error));
 
  Debug(net, 1, "[admin] The admin '{}' ({}) made an error and has been disconnected: '{}'", this->admin_name, this->admin_version, error_message);
 
  return this->CloseConnection(true);
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendProtocol()
{
  this->status = AdminStatus::Active;
 
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerProtocol);
 
  /* announce the protocol version */
  p->Send_uint8(NETWORK_GAME_ADMIN_VERSION);
 
  for (AdminUpdateType i : EnumRange(AdminUpdateType::End)) {
    p->Send_bool  (true);
    p->Send_uint16(to_underlying(i));
    p->Send_uint16(_admin_update_type_frequencies[i].base());
  }
 
  p->Send_bool(false);
  this->SendPacket(std::move(p));
 
  return this->SendWelcome();
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendWelcome()
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerWelcome);
 
  p->Send_string(_settings_client.network.server_name);
  p->Send_string(GetNetworkRevisionString());
  p->Send_bool  (_network_dedicated);
 
  p->Send_string(""); // Used to be map-name.
  p->Send_uint32(_settings_game.game_creation.generation_seed);
  p->Send_uint8 (to_underlying(_settings_game.game_creation.landscape));
  p->Send_uint32(TimerGameCalendar::ConvertYMDToDate(_settings_game.game_creation.starting_year, 0, 1).base());
  p->Send_uint16(Map::SizeX());
  p->Send_uint16(Map::SizeY());
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendNewGame()
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerNewGame);
  this->SendPacket(std::move(p));
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendShutdown()
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerShutdown);
  this->SendPacket(std::move(p));
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendDate()
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerDate);
 
  p->Send_uint32(TimerGameCalendar::date.base());
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientJoin(ClientID client_id)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerClientJoin);
 
  p->Send_uint32(to_underlying(client_id));
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientInfo(const NetworkClientSocket *cs, const NetworkClientInfo *ci)
{
  /* Only send data when we're a proper client, not just someone trying to query the server. */
  if (ci == nullptr) return NetworkRecvStatus::Okay;
 
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerClientInfo);
 
  p->Send_uint32(to_underlying(ci->client_id));
  p->Send_string(cs == nullptr ? "" : const_cast<NetworkAddress &>(cs->client_address).GetHostname());
  p->Send_string(ci->client_name);
  p->Send_uint8 (0); // Used to be language
  p->Send_uint32(ci->join_date.base());
  p->Send_uint8 (ci->client_playas);
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}
 

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientUpdate(const NetworkClientInfo *ci)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerClientUpdate);
 
  p->Send_uint32(to_underlying(ci->client_id));
  p->Send_string(ci->client_name);
  p->Send_uint8 (ci->client_playas);
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientQuit(ClientID client_id)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerClientQuit);
 
  p->Send_uint32(to_underlying(client_id));
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientError(ClientID client_id, NetworkErrorCode error)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerClientError);
 
  p->Send_uint32(to_underlying(client_id));
  p->Send_uint8(to_underlying(error));
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyNew(CompanyID company_id)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCompanyNew);
  p->Send_uint8(company_id);
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyInfo(const Company *c)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCompanyInfo);
 
  p->Send_uint8 (c->index);
  p->Send_string(GetString(STR_COMPANY_NAME, c->index));
  p->Send_string(GetString(STR_PRESIDENT_NAME, c->index));
  p->Send_uint8(to_underlying(c->colour));
  p->Send_bool  (true);
  p->Send_uint32(c->inaugurated_year.base());
  p->Send_bool  (c->is_ai);
  p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}
 

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyUpdate(const Company *c)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCompanyUpdate);
 
  p->Send_uint8 (c->index);
  p->Send_string(GetString(STR_COMPANY_NAME, c->index));
  p->Send_string(GetString(STR_PRESIDENT_NAME, c->index));
  p->Send_uint8(to_underlying(c->colour));
  p->Send_bool  (true);
  p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason acrr)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCompanyRemove);
 
  p->Send_uint8(company_id);
  p->Send_uint8(to_underlying(acrr));
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyEconomy()
{
  for (const Company *company : Company::Iterate()) {
    /* Get the income. */
    Money income = -std::reduce(std::begin(company->yearly_expenses[0]), std::end(company->yearly_expenses[0]));
 
    auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCompanyEconomy);
 
    p->Send_uint8(company->index);
 
    /* Current information. */
    p->Send_uint64(company->money);
    p->Send_uint64(company->current_loan);
    p->Send_uint64(income);
    p->Send_uint16(static_cast<uint16_t>(std::min<uint64_t>(UINT16_MAX, company->cur_economy.delivered_cargo.GetSum<OverflowSafeInt64>())));
 
    /* Send stats for the last 2 quarters. */
    for (uint i = 0; i < 2; i++) {
      p->Send_uint64(company->old_economy[i].company_value);
      p->Send_uint16(company->old_economy[i].performance_history);
      p->Send_uint16(static_cast<uint16_t>(std::min<uint64_t>(UINT16_MAX, company->old_economy[i].delivered_cargo.GetSum<OverflowSafeInt64>())));
    }
 
    this->SendPacket(std::move(p));
  }
 
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyStats()
{
  /* Fetch the latest version of the stats. */
  NetworkCompanyStatsArray company_stats = NetworkGetCompanyStats();
 
  /* Go through all the companies. */
  for (const Company *company : Company::Iterate()) {
    auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCompanyStatistics);
 
    /* Send the information. */
    p->Send_uint8(company->index);
    for (uint16_t value : company_stats[company->index].num_vehicle) p->Send_uint16(value);
    for (uint16_t value : company_stats[company->index].num_station) p->Send_uint16(value);
 
    this->SendPacket(std::move(p));
  }
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendChat(NetworkAction action, NetworkChatDestinationType desttype, ClientID client_id, std::string_view msg, int64_t data)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerChat);
 
  p->Send_uint8(to_underlying(action));
  p->Send_uint8(to_underlying(desttype));
  p->Send_uint32(to_underlying(client_id));
  p->Send_string(msg);
  p->Send_uint64(data);
 
  this->SendPacket(std::move(p));
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendRconEnd(std::string_view command)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerRemoteConsoleCommandEnd);
 
  p->Send_string(command);
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendRcon(uint16_t colour, std::string_view result)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerRemoteConsoleCommand);
 
  p->Send_uint16(colour);
  p->Send_string(result);
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminRemoteConsoleCommand(Packet &p)
{
  if (this->status <= AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  std::string command = p.Recv_string(NETWORK_RCONCOMMAND_LENGTH);
 
  Debug(net, 3, "[admin] Rcon command from '{}' ({}): {}", this->admin_name, this->admin_version, command);
 
  _redirect_console_to_admin = this->index;
  IConsoleCmdExec(command);
  _redirect_console_to_admin = AdminID::Invalid();
  return this->SendRconEnd(command);
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminGameScript(Packet &p)
{
  if (this->status <= AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  std::string json = p.Recv_string(NETWORK_GAMESCRIPT_JSON_LENGTH);
 
  Debug(net, 6, "[admin] GameScript JSON from '{}' ({}): {}", this->admin_name, this->admin_version, json);
 
  Game::NewEvent(new ScriptEventAdminPort(json));
  return NetworkRecvStatus::Okay;
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminPing(Packet &p)
{
  if (this->status <= AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  uint32_t d1 = p.Recv_uint32();
 
  Debug(net, 6, "[admin] Ping from '{}' ({}): {}", this->admin_name, this->admin_version, d1);
 
  return this->SendPong(d1);
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendConsole(std::string_view origin, std::string_view string)
{
  /* If the length of both strings, plus the 2 '\0' terminations and 3 bytes of the packet
   * are bigger than the MTU, just ignore the message. Better safe than sorry. It should
   * never occur though as the longest strings are chat messages, which are still 30%
   * smaller than COMPAT_MTU. */
  if (origin.size() + string.size() + 2 + 3 >= COMPAT_MTU) return NetworkRecvStatus::Okay;
 
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerConsole);
 
  p->Send_string(origin);
  p->Send_string(string);
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendGameScript(std::string_view json)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerGameScript);
 
  p->Send_string(json);
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendPong(uint32_t d1)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerPong);
 
  p->Send_uint32(d1);
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCmdNames()
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCommandNames);
 
  for (uint16_t i = 0; i < to_underlying(Commands::End); i++) {
    std::string_view cmdname = GetCommandName(static_cast<Commands>(i));
 
    /* Should COMPAT_MTU be exceeded, start a new packet
     * (magic 5: 1 bool "more data" and one uint16_t "command id", one
     * byte for string '\0' termination and 1 bool "no more data" */
    if (!p->CanWriteToPacket(cmdname.size() + 5)) {
      p->Send_bool(false);
      this->SendPacket(std::move(p));
 
      p = std::make_unique<Packet>(this, PacketAdminType::ServerCommandNames);
    }
 
    p->Send_bool(true);
    p->Send_uint16(i);
    p->Send_string(cmdname);
  }
 
  /* Marker to notify the end of the packet has been reached. */
  p->Send_bool(false);
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCmdLogging(ClientID client_id, const CommandPacket &cp)
{
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerCommandLogging);
 
  p->Send_uint32(to_underlying(client_id));
  p->Send_uint8 (cp.company);
  p->Send_uint16(to_underlying(cp.cmd));
  p->Send_buffer(cp.data);
  p->Send_uint32(cp.frame);
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}
 
/***********
 * Receiving functions
 ************/
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminJoin(Packet &p)
{
  if (this->status != AdminStatus::Inactive) return this->SendError(NetworkErrorCode::NotExpected);
 
  if (!_settings_client.network.allow_insecure_admin_login) {
    /* You're not authorized to login using this method. */
    return this->SendError(NetworkErrorCode::NotAuthorized);
  }
 
  std::string password = p.Recv_string(NETWORK_PASSWORD_LENGTH);
 
  if (_settings_client.network.admin_password.empty() || _settings_client.network.admin_password != password) {
    /* Password is invalid */
    return this->SendError(NetworkErrorCode::WrongPassword);
  }
 
  this->admin_name = p.Recv_string(NETWORK_CLIENT_NAME_LENGTH);
  this->admin_version = p.Recv_string(NETWORK_REVISION_LENGTH);
 
  if (this->admin_name.empty() || this->admin_version.empty()) {
    /* no name or version supplied */
    return this->SendError(NetworkErrorCode::IllegalPacket);
  }
 
  Debug(net, 3, "[admin] '{}' ({}) has connected", this->admin_name, this->admin_version);
 
  return this->SendProtocol();
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminQuit(Packet &)
{
  /* The admin is leaving nothing else to do */
  return this->CloseConnection();
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminUpdateFrequency(Packet &p)
{
  if (this->status <= AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  AdminUpdateType type = static_cast<AdminUpdateType>(p.Recv_uint16());
  AdminUpdateFrequencies freq = static_cast<AdminUpdateFrequencies>(p.Recv_uint16());
 
  if (type >= AdminUpdateType::End || !_admin_update_type_frequencies[type].All(freq)) {
    /* The server does not know of this UpdateType. */
    Debug(net, 1, "[admin] Not supported update frequency {} ({}) from '{}' ({})", type, freq, this->admin_name, this->admin_version);
    return this->SendError(NetworkErrorCode::IllegalPacket);
  }
 
  this->update_frequency[type] = freq;
 
  if (type == AdminUpdateType::Console) DebugReconsiderSendRemoteMessages();
 
  return NetworkRecvStatus::Okay;
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminPoll(Packet &p)
{
  if (this->status <= AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  AdminUpdateType type = static_cast<AdminUpdateType>(p.Recv_uint8());
  uint32_t d1 = p.Recv_uint32();
 
  switch (type) {
    case AdminUpdateType::Date:
      /* The admin is requesting the current date. */
      this->SendDate();
      break;
 
    case AdminUpdateType::ClientInfo:
      /* The admin is requesting client info. */
      if (d1 == UINT32_MAX) {
        this->SendClientInfo(nullptr, NetworkClientInfo::GetByClientID(ClientID::Server));
        for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
          this->SendClientInfo(cs, cs->GetInfo());
        }
      } else {
        ClientID client{d1};
        if (client == ClientID::Server) {
          this->SendClientInfo(nullptr, NetworkClientInfo::GetByClientID(ClientID::Server));
        } else {
          const NetworkClientSocket *cs = NetworkClientSocket::GetByClientID(client);
          if (cs != nullptr) this->SendClientInfo(cs, cs->GetInfo());
        }
      }
      break;
 
    case AdminUpdateType::CompanyInfo:
      /* The admin is asking for company info. */
      if (d1 == UINT32_MAX) {
        for (const Company *company : Company::Iterate()) {
          this->SendCompanyInfo(company);
        }
      } else {
        const Company *company = Company::GetIfValid(d1);
        if (company != nullptr) this->SendCompanyInfo(company);
      }
      break;
 
    case AdminUpdateType::CompanyEconomy:
      /* The admin is requesting economy info. */
      this->SendCompanyEconomy();
      break;
 
    case AdminUpdateType::CompanyStats:
      /* the admin is requesting company stats. */
      this->SendCompanyStats();
      break;
 
    case AdminUpdateType::CmdNames:
      /* The admin is requesting the names of DoCommands. */
      this->SendCmdNames();
      break;
 
    default:
      /* An unsupported "poll" update type. */
      Debug(net, 1, "[admin] Not supported poll {} ({}) from '{}' ({}).", type, d1, this->admin_name, this->admin_version);
      return this->SendError(NetworkErrorCode::IllegalPacket);
  }
 
  return NetworkRecvStatus::Okay;
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminChat(Packet &p)
{
  if (this->status <= AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  NetworkAction action = static_cast<NetworkAction>(p.Recv_uint8());
  NetworkChatDestinationType desttype = static_cast<NetworkChatDestinationType>(p.Recv_uint8());
  int dest = p.Recv_uint32();
 
  std::string msg = p.Recv_string(NETWORK_CHAT_LENGTH);
 
  switch (action) {
    case NetworkAction::ChatBroadcast:
    case NetworkAction::ChatClient:
    case NetworkAction::ChatTeam:
    case NetworkAction::ServerMessage:
      NetworkServerSendChat(action, desttype, dest, msg, _network_own_client_id, 0, true);
      break;
 
    default:
      Debug(net, 1, "[admin] Invalid chat action {} from admin '{}' ({}).", action, this->admin_name, this->admin_version);
      return this->SendError(NetworkErrorCode::IllegalPacket);
  }
 
  return NetworkRecvStatus::Okay;
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminExternalChat(Packet &p)
{
  if (this->status <= AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  std::string source = p.Recv_string(NETWORK_CHAT_LENGTH);
  ExtendedTextColour colour = ExtendedTextColour::FromNetwork(p.Recv_uint16());
  std::string user = p.Recv_string(NETWORK_CHAT_LENGTH);
  std::string msg = p.Recv_string(NETWORK_CHAT_LENGTH);
 
  if (!IsValidConsoleColour(colour)) {
    Debug(net, 1, "[admin] Not supported chat colour {} ({}, {}, {}) from '{}' ({}).", colour.ToNetwork(), source, user, msg, this->admin_name, this->admin_version);
    return this->SendError(NetworkErrorCode::IllegalPacket);
  }
 
  NetworkServerSendExternalChat(source, colour, user, msg);
 
  return NetworkRecvStatus::Okay;
}
 
/*
 * Secure authentication send and receive methods.
 */
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminJoinSecure(Packet &p)
{
  if (this->status != AdminStatus::Inactive) return this->SendError(NetworkErrorCode::NotExpected);
 
  this->admin_name = p.Recv_string(NETWORK_CLIENT_NAME_LENGTH);
  this->admin_version = p.Recv_string(NETWORK_REVISION_LENGTH);
  NetworkAuthenticationMethodMask method_mask{p.Recv_uint16()};
 
  /* Always exclude key exchange only, as that provides no credential checking. */
  method_mask.Reset(NetworkAuthenticationMethod::X25519_KeyExchangeOnly);
 
  if (this->admin_name.empty() || this->admin_version.empty()) {
    /* No name or version supplied. */
    return this->SendError(NetworkErrorCode::IllegalPacket);
  }
 
  auto handler = NetworkAuthenticationServerHandler::Create(&_admin_password_provider, &_admin_authorized_key_handler, method_mask);
  if (!handler->CanBeUsed()) return this->SendError(NetworkErrorCode::NoAuthenticationMethodAvailable);
 
  this->authentication_handler = std::move(handler);
  Debug(net, 3, "[admin] '{}' ({}) has connected", this->admin_name, this->admin_version);
 
  return this->SendAuthRequest();
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendAuthRequest()
{
  this->status = AdminStatus::Authenticate;
 
  Debug(net, 6, "[admin] '{}' ({}) authenticating using {}", this->admin_name, this->admin_version, this->authentication_handler->GetName());
 
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerAuthenticationRequest);
  this->authentication_handler->SendRequest(*p);
 
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}

NetworkRecvStatus ServerNetworkAdminSocketHandler::SendEnableEncryption()
{
  if (this->status != AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  auto p = std::make_unique<Packet>(this, PacketAdminType::ServerEnableEncryption);
  this->authentication_handler->SendEnableEncryption(*p);
  this->SendPacket(std::move(p));
 
  return NetworkRecvStatus::Okay;
}
 
NetworkRecvStatus ServerNetworkAdminSocketHandler::ReceiveAdminAuthenticationResponse(Packet &p)
{
  if (this->status != AdminStatus::Authenticate) return this->SendError(NetworkErrorCode::NotExpected);
 
  switch (this->authentication_handler->ReceiveResponse(p)) {
    case NetworkAuthenticationServerHandler::ResponseResult::Authenticated:
      Debug(net, 3, "[admin] '{}' ({}) authenticated", this->admin_name, this->admin_version);
 
      this->SendEnableEncryption();
 
      this->receive_encryption_handler = this->authentication_handler->CreateClientToServerEncryptionHandler();
      this->send_encryption_handler = this->authentication_handler->CreateServerToClientEncryptionHandler();
      this->authentication_handler = nullptr;
      return this->SendProtocol();
 
    case NetworkAuthenticationServerHandler::ResponseResult::RetryNextMethod:
      Debug(net, 6, "[admin] '{}' ({}) authentication failed, trying next method", this->admin_name, this->admin_version);
      return this->SendAuthRequest();
 
    case NetworkAuthenticationServerHandler::ResponseResult::NotAuthenticated:
    default:
      Debug(net, 3, "[admin] '{}' ({}) authentication failed", this->admin_name, this->admin_version);
      return this->SendError(NetworkErrorCode::WrongPassword);
  }
}
 
/*
 * Useful wrapper functions
 */

void NetworkAdminClientInfo(const NetworkClientSocket *cs, bool new_client)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::ClientInfo].Test(AdminUpdateFrequency::Automatic)) {
      as->SendClientInfo(cs, cs->GetInfo());
      if (new_client) {
        as->SendClientJoin(cs->client_id);
      }
    }
  }
}

void NetworkAdminClientUpdate(const NetworkClientInfo *ci)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::ClientInfo].Test(AdminUpdateFrequency::Automatic)) {
      as->SendClientUpdate(ci);
    }
  }
}

void NetworkAdminClientQuit(ClientID client_id)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::ClientInfo].Test(AdminUpdateFrequency::Automatic)) {
      as->SendClientQuit(client_id);
    }
  }
}

void NetworkAdminClientError(ClientID client_id, NetworkErrorCode error_code)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::ClientInfo].Test(AdminUpdateFrequency::Automatic)) {
      as->SendClientError(client_id, error_code);
    }
  }
}

void NetworkAdminCompanyNew(const Company *company)
{
  if (company == nullptr) {
    Debug(net, 1, "[admin] Empty company given for update");
    return;
  }
 
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::CompanyInfo] != AdminUpdateFrequency::Automatic) continue;
 
    as->SendCompanyNew(company->index);
    as->SendCompanyInfo(company);
  }
}

void NetworkAdminCompanyUpdate(const Company *company)
{
  if (company == nullptr) return;
 
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::CompanyInfo] != AdminUpdateFrequency::Automatic) continue;
 
    as->SendCompanyUpdate(company);
  }
}

void NetworkAdminCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    as->SendCompanyRemove(company_id, bcrr);
  }
}
 

void NetworkAdminChat(NetworkAction action, NetworkChatDestinationType desttype, ClientID client_id, std::string_view msg, int64_t data, bool from_admin)
{
  if (from_admin) return;
 
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::Chat].Test(AdminUpdateFrequency::Automatic)) {
      as->SendChat(action, desttype, client_id, msg, data);
    }
  }
}

void NetworkServerSendAdminRcon(AdminID admin_index, ExtendedTextColour colour_code, std::string_view string)
{
  ServerNetworkAdminSocketHandler::Get(admin_index)->SendRcon(colour_code.ToNetwork(), string);
}

void NetworkAdminConsole(std::string_view origin, std::string_view string)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::Console].Test(AdminUpdateFrequency::Automatic)) {
      as->SendConsole(origin, string);
    }
  }
}

void NetworkAdminGameScript(std::string_view json)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::Gamescript].Test(AdminUpdateFrequency::Automatic)) {
      as->SendGameScript(json);
    }
  }
}

void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket &cp)
{
  ClientID client_id = owner == nullptr ? _network_own_client_id : owner->client_id;
 
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    if (as->update_frequency[AdminUpdateType::CmdLogging].Test(AdminUpdateFrequency::Automatic)) {
      as->SendCmdLogging(client_id, cp);
    }
  }
}

void ServerNetworkAdminSocketHandler::WelcomeAll()
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    as->SendWelcome();
  }
}

void NetworkAdminUpdate(AdminUpdateFrequency freq)
{
  for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
    for (AdminUpdateType i : EnumRange(AdminUpdateType::End)) {
      if (as->update_frequency[i].Test(freq)) {
        /* Update the admin for the required details */
        switch (i) {
          case AdminUpdateType::Date:
            as->SendDate();
            break;
 
          case AdminUpdateType::CompanyEconomy:
            as->SendCompanyEconomy();
            break;
 
          case AdminUpdateType::CompanyStats:
            as->SendCompanyStats();
            break;
 
          default: NOT_REACHED();
        }
      }
    }
  }
}