network_udp.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 "../date_func.h"
#include "../map_func.h"
#include "../debug.h"
#include "network_gamelist.h"
#include "network_internal.h"
#include "network_udp.h"
#include "network.h"
#include "../core/endian_func.hpp"
#include "../company_base.h"
#include "../thread.h"
#include "../rev.h"
#include "../newgrf_text.h"
#include "../strings_func.h"
#include "table/strings.h"
#include <mutex>
 
#include "core/udp.h"
 
#include "../safeguards.h"
 
static uint64 _session_key = 0;
 
static const std::chrono::minutes ADVERTISE_NORMAL_INTERVAL(15); 
static const std::chrono::seconds ADVERTISE_RETRY_INTERVAL(10); 
static const uint32 ADVERTISE_RETRY_TIMES     =              3; 
 
static bool _network_udp_server;         
static uint16 _network_udp_broadcast;    
static uint8 _network_advertise_retries; 
 
struct UDPSocket {
  const std::string name;                     
  std::mutex mutex;                           
  NetworkUDPSocketHandler *socket;            
  std::atomic<int> receive_iterations_locked; 
 
  UDPSocket(const std::string &name_) : name(name_), socket(nullptr) {}
 
  void Close()
  {
    std::lock_guard<std::mutex> lock(mutex);
    socket->Close();
    delete socket;
    socket = nullptr;
  }
 
  void ReceivePackets()
  {
    std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
    if (!lock.try_lock()) {
      if (++receive_iterations_locked % 32 == 0) {
        DEBUG(net, 0, "[udp] %s background UDP loop processing appears to be blocked. Your OS may be low on UDP send buffers.", name.c_str());
      }
      return;
    }
 
    receive_iterations_locked.store(0);
    socket->ReceivePackets();
  }
};
 
static UDPSocket _udp_client("Client"); 
static UDPSocket _udp_server("Server"); 
static UDPSocket _udp_master("Master"); 
 
static void DoNetworkUDPQueryServer(NetworkAddress &address, bool needs_mutex, bool manually)
{
  /* Clear item in gamelist */
  NetworkGameList *item = CallocT<NetworkGameList>(1);
  address.GetAddressAsString(item->info.server_name, lastof(item->info.server_name));
  strecpy(item->info.hostname, address.GetHostname(), lastof(item->info.hostname));
  item->address = address;
  item->manually = manually;
  NetworkGameListAddItemDelayed(item);
 
  std::unique_lock<std::mutex> lock(_udp_client.mutex, std::defer_lock);
  if (needs_mutex) lock.lock();
  /* Init the packet */
  Packet p(PACKET_UDP_CLIENT_FIND_SERVER);
  if (_udp_client.socket != nullptr) _udp_client.socket->SendPacket(&p, &address);
}
 
void NetworkUDPQueryServer(NetworkAddress address, bool manually)
{
  if (address.IsResolved() || !StartNewThread(nullptr, "ottd:udp-query", &DoNetworkUDPQueryServer, std::move(address), true, std::move(manually))) {
    DoNetworkUDPQueryServer(address, true, manually);
  }
}
 
 
class MasterNetworkUDPSocketHandler : public NetworkUDPSocketHandler {
protected:
  void Receive_MASTER_ACK_REGISTER(Packet *p, NetworkAddress *client_addr) override;
  void Receive_MASTER_SESSION_KEY(Packet *p, NetworkAddress *client_addr) override;
public:
  MasterNetworkUDPSocketHandler(NetworkAddressList *addresses) : NetworkUDPSocketHandler(addresses) {}
  virtual ~MasterNetworkUDPSocketHandler() {}
};
 
void MasterNetworkUDPSocketHandler::Receive_MASTER_ACK_REGISTER(Packet *p, NetworkAddress *client_addr)
{
  _network_advertise_retries = 0;
  DEBUG(net, 2, "[udp] advertising on master server successful (%s)", NetworkAddress::AddressFamilyAsString(client_addr->GetAddress()->ss_family));
 
  /* We are advertised, but we don't want to! */
  if (!_settings_client.network.server_advertise) NetworkUDPRemoveAdvertise(false);
}
 
void MasterNetworkUDPSocketHandler::Receive_MASTER_SESSION_KEY(Packet *p, NetworkAddress *client_addr)
{
  _session_key = p->Recv_uint64();
  DEBUG(net, 2, "[udp] received new session key from master server (%s)", NetworkAddress::AddressFamilyAsString(client_addr->GetAddress()->ss_family));
}
 
 
class ServerNetworkUDPSocketHandler : public NetworkUDPSocketHandler {
protected:
  void Receive_CLIENT_FIND_SERVER(Packet *p, NetworkAddress *client_addr) override;
  void Receive_CLIENT_DETAIL_INFO(Packet *p, NetworkAddress *client_addr) override;
  void Receive_CLIENT_GET_NEWGRFS(Packet *p, NetworkAddress *client_addr) override;
public:
  ServerNetworkUDPSocketHandler(NetworkAddressList *addresses) : NetworkUDPSocketHandler(addresses) {}
  virtual ~ServerNetworkUDPSocketHandler() {}
};
 
void ServerNetworkUDPSocketHandler::Receive_CLIENT_FIND_SERVER(Packet *p, NetworkAddress *client_addr)
{
  /* Just a fail-safe.. should never happen */
  if (!_network_udp_server) {
    return;
  }
 
  NetworkGameInfo ngi;
 
  /* Update some game_info */
  ngi.clients_on     = _network_game_info.clients_on;
  ngi.start_date     = ConvertYMDToDate(_settings_game.game_creation.starting_year, 0, 1);
 
  ngi.server_lang    = _settings_client.network.server_lang;
  ngi.use_password   = !StrEmpty(_settings_client.network.server_password);
  ngi.clients_max    = _settings_client.network.max_clients;
  ngi.companies_on   = (byte)Company::GetNumItems();
  ngi.companies_max  = _settings_client.network.max_companies;
  ngi.spectators_on  = NetworkSpectatorCount();
  ngi.spectators_max = _settings_client.network.max_spectators;
  ngi.game_date      = _date;
  ngi.map_width      = MapSizeX();
  ngi.map_height     = MapSizeY();
  ngi.map_set        = _settings_game.game_creation.landscape;
  ngi.dedicated      = _network_dedicated;
  ngi.grfconfig      = _grfconfig;
 
  strecpy(ngi.map_name, _network_game_info.map_name, lastof(ngi.map_name));
  strecpy(ngi.server_name, _settings_client.network.server_name, lastof(ngi.server_name));
  strecpy(ngi.server_revision, GetNetworkRevisionString(), lastof(ngi.server_revision));
 
  Packet packet(PACKET_UDP_SERVER_RESPONSE);
  this->SendNetworkGameInfo(&packet, &ngi);
 
  /* Let the client know that we are here */
  this->SendPacket(&packet, client_addr);
 
  DEBUG(net, 2, "[udp] queried from %s", client_addr->GetHostname());
}
 
void ServerNetworkUDPSocketHandler::Receive_CLIENT_DETAIL_INFO(Packet *p, NetworkAddress *client_addr)
{
  /* Just a fail-safe.. should never happen */
  if (!_network_udp_server) return;
 
  Packet packet(PACKET_UDP_SERVER_DETAIL_INFO);
 
  /* Send the amount of active companies */
  packet.Send_uint8 (NETWORK_COMPANY_INFO_VERSION);
  packet.Send_uint8 ((uint8)Company::GetNumItems());
 
  /* Fetch the latest version of the stats */
  NetworkCompanyStats company_stats[MAX_COMPANIES];
  NetworkPopulateCompanyStats(company_stats);
 
  /* The minimum company information "blob" size. */
  static const uint MIN_CI_SIZE = 54;
  uint max_cname_length = NETWORK_COMPANY_NAME_LENGTH;
 
  if (Company::GetNumItems() * (MIN_CI_SIZE + NETWORK_COMPANY_NAME_LENGTH) >= (uint)SEND_MTU - packet.size) {
    /* Assume we can at least put the company information in the packets. */
    assert(Company::GetNumItems() * MIN_CI_SIZE < (uint)SEND_MTU - packet.size);
 
    /* At this moment the company names might not fit in the
     * packet. Check whether that is really the case. */
 
    for (;;) {
      int free = SEND_MTU - packet.size;
      for (const Company *company : Company::Iterate()) {
        char company_name[NETWORK_COMPANY_NAME_LENGTH];
        SetDParam(0, company->index);
        GetString(company_name, STR_COMPANY_NAME, company_name + max_cname_length - 1);
        free -= MIN_CI_SIZE;
        free -= (int)strlen(company_name);
      }
      if (free >= 0) break;
 
      /* Try again, with slightly shorter strings. */
      assert(max_cname_length > 0);
      max_cname_length--;
    }
  }
 
  /* Go through all the companies */
  for (const Company *company : Company::Iterate()) {
    /* Send the information */
    this->SendCompanyInformation(&packet, company, &company_stats[company->index], max_cname_length);
  }
 
  this->SendPacket(&packet, client_addr);
}
 
void ServerNetworkUDPSocketHandler::Receive_CLIENT_GET_NEWGRFS(Packet *p, NetworkAddress *client_addr)
{
  uint8 num_grfs;
  uint i;
 
  const GRFConfig *in_reply[NETWORK_MAX_GRF_COUNT];
  uint8 in_reply_count = 0;
  size_t packet_len = 0;
 
  DEBUG(net, 6, "[udp] newgrf data request from %s", client_addr->GetAddressAsString().c_str());
 
  num_grfs = p->Recv_uint8 ();
  if (num_grfs > NETWORK_MAX_GRF_COUNT) return;
 
  for (i = 0; i < num_grfs; i++) {
    GRFIdentifier c;
    const GRFConfig *f;
 
    this->ReceiveGRFIdentifier(p, &c);
 
    /* Find the matching GRF file */
    f = FindGRFConfig(c.grfid, FGCM_EXACT, c.md5sum);
    if (f == nullptr) continue; // The GRF is unknown to this server
 
    /* If the reply might exceed the size of the packet, only reply
     * the current list and do not send the other data.
     * The name could be an empty string, if so take the filename. */
    packet_len += sizeof(c.grfid) + sizeof(c.md5sum) +
        std::min(strlen(f->GetName()) + 1, (size_t)NETWORK_GRF_NAME_LENGTH);
    if (packet_len > SEND_MTU - 4) { // 4 is 3 byte header + grf count in reply
      break;
    }
    in_reply[in_reply_count] = f;
    in_reply_count++;
  }
 
  if (in_reply_count == 0) return;
 
  Packet packet(PACKET_UDP_SERVER_NEWGRFS);
  packet.Send_uint8(in_reply_count);
  for (i = 0; i < in_reply_count; i++) {
    char name[NETWORK_GRF_NAME_LENGTH];
 
    /* The name could be an empty string, if so take the filename */
    strecpy(name, in_reply[i]->GetName(), lastof(name));
    this->SendGRFIdentifier(&packet, &in_reply[i]->ident);
    packet.Send_string(name);
  }
 
  this->SendPacket(&packet, client_addr);
}
 
 
class ClientNetworkUDPSocketHandler : public NetworkUDPSocketHandler {
protected:
  void Receive_SERVER_RESPONSE(Packet *p, NetworkAddress *client_addr) override;
  void Receive_MASTER_RESPONSE_LIST(Packet *p, NetworkAddress *client_addr) override;
  void Receive_SERVER_NEWGRFS(Packet *p, NetworkAddress *client_addr) override;
  void HandleIncomingNetworkGameInfoGRFConfig(GRFConfig *config) override;
public:
  virtual ~ClientNetworkUDPSocketHandler() {}
};
 
void ClientNetworkUDPSocketHandler::Receive_SERVER_RESPONSE(Packet *p, NetworkAddress *client_addr)
{
  NetworkGameList *item;
 
  /* Just a fail-safe.. should never happen */
  if (_network_udp_server) return;
 
  DEBUG(net, 4, "[udp] server response from %s", client_addr->GetAddressAsString().c_str());
 
  /* Find next item */
  item = NetworkGameListAddItem(*client_addr);
 
  ClearGRFConfigList(&item->info.grfconfig);
  this->ReceiveNetworkGameInfo(p, &item->info);
 
  item->info.compatible = true;
  {
    /* Checks whether there needs to be a request for names of GRFs and makes
     * the request if necessary. GRFs that need to be requested are the GRFs
     * that do not exist on the clients system and we do not have the name
     * resolved of, i.e. the name is still UNKNOWN_GRF_NAME_PLACEHOLDER.
     * The in_request array and in_request_count are used so there is no need
     * to do a second loop over the GRF list, which can be relatively expensive
     * due to the string comparisons. */
    const GRFConfig *in_request[NETWORK_MAX_GRF_COUNT];
    const GRFConfig *c;
    uint in_request_count = 0;
 
    for (c = item->info.grfconfig; c != nullptr; c = c->next) {
      if (c->status == GCS_NOT_FOUND) item->info.compatible = false;
      if (c->status != GCS_NOT_FOUND || strcmp(c->GetName(), UNKNOWN_GRF_NAME_PLACEHOLDER) != 0) continue;
      in_request[in_request_count] = c;
      in_request_count++;
    }
 
    if (in_request_count > 0) {
      /* There are 'unknown' GRFs, now send a request for them */
      uint i;
      Packet packet(PACKET_UDP_CLIENT_GET_NEWGRFS);
 
      packet.Send_uint8(in_request_count);
      for (i = 0; i < in_request_count; i++) {
        this->SendGRFIdentifier(&packet, &in_request[i]->ident);
      }
 
      this->SendPacket(&packet, &item->address);
    }
  }
 
  if (item->info.hostname[0] == '\0') {
    seprintf(item->info.hostname, lastof(item->info.hostname), "%s", client_addr->GetHostname());
  }
 
  if (client_addr->GetAddress()->ss_family == AF_INET6) {
    strecat(item->info.server_name, " (IPv6)", lastof(item->info.server_name));
  }
 
  /* Check if we are allowed on this server based on the revision-match */
  item->info.version_compatible = IsNetworkCompatibleVersion(item->info.server_revision);
  item->info.compatible &= item->info.version_compatible; // Already contains match for GRFs
 
  item->online = true;
 
  UpdateNetworkGameWindow();
}
 
void ClientNetworkUDPSocketHandler::Receive_MASTER_RESPONSE_LIST(Packet *p, NetworkAddress *client_addr)
{
  /* packet begins with the protocol version (uint8)
   * then an uint16 which indicates how many
   * ip:port pairs are in this packet, after that
   * an uint32 (ip) and an uint16 (port) for each pair.
   */
 
  ServerListType type = (ServerListType)(p->Recv_uint8() - 1);
 
  if (type < SLT_END) {
    for (int i = p->Recv_uint16(); i != 0 ; i--) {
      sockaddr_storage addr_storage;
      memset(&addr_storage, 0, sizeof(addr_storage));
 
      if (type == SLT_IPv4) {
        addr_storage.ss_family = AF_INET;
        ((sockaddr_in*)&addr_storage)->sin_addr.s_addr = TO_LE32(p->Recv_uint32());
      } else {
        assert(type == SLT_IPv6);
        addr_storage.ss_family = AF_INET6;
        byte *addr = (byte*)&((sockaddr_in6*)&addr_storage)->sin6_addr;
        for (uint i = 0; i < sizeof(in6_addr); i++) *addr++ = p->Recv_uint8();
      }
      NetworkAddress addr(addr_storage, type == SLT_IPv4 ? sizeof(sockaddr_in) : sizeof(sockaddr_in6));
      addr.SetPort(p->Recv_uint16());
 
      /* Somehow we reached the end of the packet */
      if (this->HasClientQuit()) return;
 
      DoNetworkUDPQueryServer(addr, false, false);
    }
  }
}
 
void ClientNetworkUDPSocketHandler::Receive_SERVER_NEWGRFS(Packet *p, NetworkAddress *client_addr)
{
  uint8 num_grfs;
  uint i;
 
  DEBUG(net, 6, "[udp] newgrf data reply from %s", client_addr->GetAddressAsString().c_str());
 
  num_grfs = p->Recv_uint8 ();
  if (num_grfs > NETWORK_MAX_GRF_COUNT) return;
 
  for (i = 0; i < num_grfs; i++) {
    char name[NETWORK_GRF_NAME_LENGTH];
    GRFIdentifier c;
 
    this->ReceiveGRFIdentifier(p, &c);
    p->Recv_string(name, sizeof(name));
 
    /* An empty name is not possible under normal circumstances
     * and causes problems when showing the NewGRF list. */
    if (StrEmpty(name)) continue;
 
    /* Try to find the GRFTextWrapper for the name of this GRF ID and MD5sum tuple.
     * If it exists and not resolved yet, then name of the fake GRF is
     * overwritten with the name from the reply. */
    GRFTextWrapper unknown_name = FindUnknownGRFName(c.grfid, c.md5sum, false);
    if (unknown_name && strcmp(GetGRFStringFromGRFText(unknown_name), UNKNOWN_GRF_NAME_PLACEHOLDER) == 0) {
      AddGRFTextToList(unknown_name, name);
    }
  }
}
 
void ClientNetworkUDPSocketHandler::HandleIncomingNetworkGameInfoGRFConfig(GRFConfig *config)
{
  /* Find the matching GRF file */
  const GRFConfig *f = FindGRFConfig(config->ident.grfid, FGCM_EXACT, config->ident.md5sum);
  if (f == nullptr) {
    /* Don't know the GRF, so mark game incompatible and the (possibly)
     * already resolved name for this GRF (another server has sent the
     * name of the GRF already */
    config->name = FindUnknownGRFName(config->ident.grfid, config->ident.md5sum, true);
    config->status = GCS_NOT_FOUND;
  } else {
    config->filename = f->filename;
    config->name = f->name;
    config->info = f->info;
    config->url = f->url;
  }
  SetBit(config->flags, GCF_COPY);
}
 
static void NetworkUDPBroadCast(NetworkUDPSocketHandler *socket)
{
  for (NetworkAddress &addr : _broadcast_list) {
    Packet p(PACKET_UDP_CLIENT_FIND_SERVER);
 
    DEBUG(net, 4, "[udp] broadcasting to %s", addr.GetHostname());
 
    socket->SendPacket(&p, &addr, true, true);
  }
}
 
 
void NetworkUDPQueryMasterServer()
{
  Packet p(PACKET_UDP_CLIENT_GET_LIST);
  NetworkAddress out_addr(NETWORK_MASTER_SERVER_HOST, NETWORK_MASTER_SERVER_PORT);
 
  /* packet only contains protocol version */
  p.Send_uint8(NETWORK_MASTER_SERVER_VERSION);
  p.Send_uint8(SLT_AUTODETECT);
 
  std::lock_guard<std::mutex> lock(_udp_client.mutex);
  _udp_client.socket->SendPacket(&p, &out_addr, true);
 
  DEBUG(net, 2, "[udp] master server queried at %s", out_addr.GetAddressAsString().c_str());
}
 
void NetworkUDPSearchGame()
{
  /* We are still searching.. */
  if (_network_udp_broadcast > 0) return;
 
  DEBUG(net, 0, "[udp] searching server");
 
  NetworkUDPBroadCast(_udp_client.socket);
  _network_udp_broadcast = 300; // Stay searching for 300 ticks
}
 
static void NetworkUDPRemoveAdvertiseThread()
{
  DEBUG(net, 1, "[udp] removing advertise from master server");
 
  /* Find somewhere to send */
  NetworkAddress out_addr(NETWORK_MASTER_SERVER_HOST, NETWORK_MASTER_SERVER_PORT);
 
  /* Send the packet */
  Packet p(PACKET_UDP_SERVER_UNREGISTER);
  /* Packet is: Version, server_port */
  p.Send_uint8 (NETWORK_MASTER_SERVER_VERSION);
  p.Send_uint16(_settings_client.network.server_port);
 
  std::lock_guard<std::mutex> lock(_udp_master.mutex);
  if (_udp_master.socket != nullptr) _udp_master.socket->SendPacket(&p, &out_addr, true);
}
 
void NetworkUDPRemoveAdvertise(bool blocking)
{
  /* Check if we are advertising */
  if (!_networking || !_network_server || !_network_udp_server) return;
 
  if (blocking || !StartNewThread(nullptr, "ottd:udp-advert", &NetworkUDPRemoveAdvertiseThread)) {
    NetworkUDPRemoveAdvertiseThread();
  }
}
 
static void NetworkUDPAdvertiseThread()
{
  /* Find somewhere to send */
  NetworkAddress out_addr(NETWORK_MASTER_SERVER_HOST, NETWORK_MASTER_SERVER_PORT);
 
  DEBUG(net, 1, "[udp] advertising to master server");
 
  /* Add a bit more messaging when we cannot get a session key */
  static byte session_key_retries = 0;
  if (_session_key == 0 && session_key_retries++ == 2) {
    DEBUG(net, 0, "[udp] advertising to the master server is failing");
    DEBUG(net, 0, "[udp]   we are not receiving the session key from the server");
    DEBUG(net, 0, "[udp]   please allow udp packets from %s to you to be delivered", out_addr.GetAddressAsString(false).c_str());
    DEBUG(net, 0, "[udp]   please allow udp packets from you to %s to be delivered", out_addr.GetAddressAsString(false).c_str());
  }
  if (_session_key != 0 && _network_advertise_retries == 0) {
    DEBUG(net, 0, "[udp] advertising to the master server is failing");
    DEBUG(net, 0, "[udp]   we are not receiving the acknowledgement from the server");
    DEBUG(net, 0, "[udp]   this usually means that the master server cannot reach us");
    DEBUG(net, 0, "[udp]   please allow udp and tcp packets to port %u to be delivered", _settings_client.network.server_port);
    DEBUG(net, 0, "[udp]   please allow udp and tcp packets from port %u to be delivered", _settings_client.network.server_port);
  }
 
  /* Send the packet */
  Packet p(PACKET_UDP_SERVER_REGISTER);
  /* Packet is: WELCOME_MESSAGE, Version, server_port */
  p.Send_string(NETWORK_MASTER_SERVER_WELCOME_MESSAGE);
  p.Send_uint8 (NETWORK_MASTER_SERVER_VERSION);
  p.Send_uint16(_settings_client.network.server_port);
  p.Send_uint64(_session_key);
 
  std::lock_guard<std::mutex> lock(_udp_master.mutex);
  if (_udp_master.socket != nullptr) _udp_master.socket->SendPacket(&p, &out_addr, true);
}
 
void NetworkUDPAdvertise()
{
  static std::chrono::steady_clock::time_point _last_advertisement = {}; 
 
  /* Check if we should send an advertise */
  if (!_networking || !_network_server || !_network_udp_server || !_settings_client.network.server_advertise) return;
 
  if (_network_need_advertise) {
    /* Forced advertisement. */
    _network_need_advertise = false;
    _network_advertise_retries = ADVERTISE_RETRY_TIMES;
  } else {
    /* Only send once every ADVERTISE_NORMAL_INTERVAL ticks */
    if (_network_advertise_retries == 0) {
      if (std::chrono::steady_clock::now() <= _last_advertisement + ADVERTISE_NORMAL_INTERVAL) return;
 
      _network_advertise_retries = ADVERTISE_RETRY_TIMES;
    } else {
      /* An actual retry. */
      if (std::chrono::steady_clock::now() <= _last_advertisement + ADVERTISE_RETRY_INTERVAL) return;
    }
  }
 
  _network_advertise_retries--;
  _last_advertisement = std::chrono::steady_clock::now();
 
  if (!StartNewThread(nullptr, "ottd:udp-advert", &NetworkUDPAdvertiseThread)) {
    NetworkUDPAdvertiseThread();
  }
}
 
void NetworkUDPInitialize()
{
  /* If not closed, then do it. */
  if (_udp_server.socket != nullptr) NetworkUDPClose();
 
  DEBUG(net, 1, "[udp] initializing listeners");
  assert(_udp_client.socket == nullptr && _udp_server.socket == nullptr && _udp_master.socket == nullptr);
 
  std::scoped_lock lock(_udp_client.mutex, _udp_server.mutex, _udp_master.mutex);
 
  _udp_client.socket = new ClientNetworkUDPSocketHandler();
 
  NetworkAddressList server;
  GetBindAddresses(&server, _settings_client.network.server_port);
  _udp_server.socket = new ServerNetworkUDPSocketHandler(&server);
 
  server.clear();
  GetBindAddresses(&server, 0);
  _udp_master.socket = new MasterNetworkUDPSocketHandler(&server);
 
  _network_udp_server = false;
  _network_udp_broadcast = 0;
  _network_advertise_retries = 0;
}
 
void NetworkUDPServerListen()
{
  std::lock_guard<std::mutex> lock(_udp_server.mutex);
  _network_udp_server = _udp_server.socket->Listen();
}
 
void NetworkUDPClose()
{
  _udp_client.Close();
  _udp_server.Close();
  _udp_master.Close();
 
  _network_udp_server = false;
  _network_udp_broadcast = 0;
  DEBUG(net, 1, "[udp] closed listeners");
}
 
void NetworkBackgroundUDPLoop()
{
  if (_network_udp_server) {
    _udp_server.ReceivePackets();
    _udp_master.ReceivePackets();
  } else {
    _udp_client.ReceivePackets();
    if (_network_udp_broadcast > 0) _network_udp_broadcast--;
  }
}