network_content.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 "../rev.h"
#include "../ai/ai.hpp"
#include "../game/game.hpp"
#include "../window_func.h"
#include "../error.h"
#include "../fileio_func.h"
#include "../newgrf.h"
#include "../base_media_base.h"
#include "../base_media_graphics.h"
#include "../base_media_music.h"
#include "../base_media_sounds.h"
#include "../settings_type.h"
#include "../strings_func.h"
#include "../timer/timer.h"
#include "../timer/timer_window.h"
#include "../core/string_consumer.hpp"
#include "network_content.h"
 
#include "table/strings.h"
 
#if defined(WITH_ZLIB)
# include <zlib.h>
# if defined(_WIN32)
    /* Required for: dup, fileno, close */
#   include <io.h>
# endif
#endif
 
#ifdef __EMSCRIPTEN__
# include <emscripten.h>
#endif
 
#include "../safeguards.h"
 
extern bool HasScenario(const ContentInfo &ci, bool md5sum);

ClientNetworkContentSocketHandler _network_content_client;

static bool HasGRFConfig(const ContentInfo &ci, bool md5sum)
{
  return FindGRFConfig(UnflattenNewGRFLabel<GrfID>(ci.unique_id), md5sum ? FindGRFConfigMode::Exact : FindGRFConfigMode::Any, md5sum ? &ci.md5sum : nullptr) != nullptr;
}

using HasContentProc = bool(const ContentInfo &ci, bool md5sum);

static HasContentProc *GetHasContentProcforContentType(ContentType type)
{
  switch (type) {
    case ContentType::NewGRF: return HasGRFConfig;
    case ContentType::BaseGraphics: return BaseGraphics::HasSet;
    case ContentType::BaseMusic: return BaseMusic::HasSet;
    case ContentType::BaseSounds: return BaseSounds::HasSet;
    case ContentType::Ai: return AI::HasAI;
    case ContentType::AiLibrary: return AI::HasAILibrary;
    case ContentType::Gs: return Game::HasGame;
    case ContentType::GsLibrary: return Game::HasGameLibrary;
    case ContentType::Scenario: return HasScenario;
    case ContentType::Heightmap: return HasScenario;
    default: return nullptr;
  }
}
 
bool ClientNetworkContentSocketHandler::ReceiveServerInfo(Packet &p)
{
  auto ci = std::make_unique<ContentInfo>();
  ci->type     = (ContentType)p.Recv_uint8();
  ci->id       = (ContentID)p.Recv_uint32();
  ci->filesize = p.Recv_uint32();
 
  ci->name        = p.Recv_string(NETWORK_CONTENT_NAME_LENGTH);
  ci->version     = p.Recv_string(NETWORK_CONTENT_VERSION_LENGTH);
  ci->url         = p.Recv_string(NETWORK_CONTENT_URL_LENGTH);
  ci->description = p.Recv_string(NETWORK_CONTENT_DESC_LENGTH, {StringValidationSetting::ReplaceWithQuestionMark, StringValidationSetting::AllowNewline});
 
  ci->unique_id = p.Recv_uint32();
  p.Recv_bytes(ci->md5sum);
 
  uint dependency_count = p.Recv_uint8();
  ci->dependencies.reserve(dependency_count);
  for (uint i = 0; i < dependency_count; i++) {
    ContentID dependency_cid = (ContentID)p.Recv_uint32();
    ci->dependencies.push_back(dependency_cid);
    this->reverse_dependency_map.emplace(dependency_cid, ci->id);
  }
 
  uint tag_count = p.Recv_uint8();
  ci->tags.reserve(tag_count);
  for (uint i = 0; i < tag_count; i++) ci->tags.push_back(p.Recv_string(NETWORK_CONTENT_TAG_LENGTH));
 
  if (!ci->IsValid()) {
    this->CloseConnection();
    return false;
  }
 
  HasContentProc *proc = GetHasContentProcforContentType(ci->type);
  if (proc != nullptr) {
    if (proc(*ci, true)) {
      ci->state = ContentInfo::State::AlreadyHere;
    } else {
      ci->state = ContentInfo::State::Unselected;
      if (proc(*ci, false)) ci->upgrade = true;
    }
  } else {
    ci->state = ContentInfo::State::Unselected;
  }
 
  /* Something we don't have and has filesize 0 does not exist in the system */
  if (ci->state == ContentInfo::State::Unselected && ci->filesize == 0) ci->state = ContentInfo::State::DoesNotExist;
 
  /* Do we already have a stub for this? */
  for (const auto &ici : this->infos) {
    if (ici->type == ci->type && ici->unique_id == ci->unique_id && ci->md5sum == ici->md5sum) {
      /* Preserve the name if possible */
      if (ci->name.empty()) ci->name = ici->name;
      if (ici->IsSelected()) ci->state = ici->state;
 
      /*
       * As ici might be selected by the content window we cannot delete that.
       * However, we want to keep most of the values of ci, except the values
       * we (just) already preserved.
       */
      *ici = *ci;
 
      this->OnReceiveContentInfo(*ici);
      return true;
    }
  }
 
  /* Missing content info? Don't list it */
  if (ci->filesize == 0) {
    return true;
  }
 
  ContentInfo *info = this->infos.emplace_back(std::move(ci)).get();
 
  /* Incoming data means that we might need to reconsider dependencies */
  ConstContentVector parents;
  this->ReverseLookupTreeDependency(parents, info);
  for (const ContentInfo *ici : parents) {
    this->CheckDependencyState(*ici);
  }
 
  this->OnReceiveContentInfo(*info);
 
  return true;
}

void ClientNetworkContentSocketHandler::RequestContentList(ContentType type)
{
  if (type == ContentType::End) {
    this->RequestContentList(ContentType::BaseGraphics);
    this->RequestContentList(ContentType::BaseMusic);
    this->RequestContentList(ContentType::BaseSounds);
    this->RequestContentList(ContentType::Scenario);
    this->RequestContentList(ContentType::Heightmap);
    this->RequestContentList(ContentType::Ai);
    this->RequestContentList(ContentType::AiLibrary);
    this->RequestContentList(ContentType::Gs);
    this->RequestContentList(ContentType::GsLibrary);
    this->RequestContentList(ContentType::NewGRF);
    return;
  }
 
  this->Connect();
 
  auto p = std::make_unique<Packet>(this, PacketContentType::ClientInfoList);
  p->Send_uint8 (to_underlying(type));
  p->Send_uint32(0xffffffff);
  p->Send_uint8 (1);
  p->Send_string("vanilla");
  p->Send_string(_openttd_content_version);
 
  /* Patchpacks can extend the list with one. In BaNaNaS metadata you can
   * add a branch in the 'compatibility' list, to filter on this. If you want
   * your patchpack to be mentioned in the BaNaNaS web-interface, create an
   * issue on https://github.com/OpenTTD/bananas-api asking for this.
 
  p->Send_string("patchpack"); // Or what-ever the name of your patchpack is.
  p->Send_string(_openttd_content_version_patchpack);
 
   */
 
  this->SendPacket(std::move(p));
}

void ClientNetworkContentSocketHandler::RequestContentList(std::span<const ContentID> content_ids)
{
  /* We can "only" send a limited number of IDs in a single packet.
   * A packet begins with the packet size and a byte for the type.
   * Then this packet adds a uint16_t for the count in this packet.
   * The rest of the packet can be used for the IDs. */
  static constexpr size_t MAX_CONTENT_IDS_PER_PACKET = (TCP_MTU - sizeof(PacketSize) - sizeof(uint8_t) - sizeof(uint16_t)) / sizeof(uint32_t);
 
  if (content_ids.empty()) return;
 
  this->Connect();
 
  for (auto it = std::begin(content_ids); it != std::end(content_ids); /* nothing */) {
    auto last = std::ranges::next(it, MAX_CONTENT_IDS_PER_PACKET, std::end(content_ids));
 
    auto p = std::make_unique<Packet>(this, PacketContentType::ClientInfoID, TCP_MTU);
    p->Send_uint16(std::distance(it, last));
 
    for (; it != last; ++it) {
      p->Send_uint32(*it);
    }
 
    this->SendPacket(std::move(p));
  }
}

void ClientNetworkContentSocketHandler::RequestContentList(ContentVector *cv, bool send_md5sum)
{
  if (cv == nullptr) return;
 
  this->Connect();
 
  assert(cv->size() < 255);
  assert(cv->size() < (TCP_MTU - sizeof(PacketSize) - sizeof(uint8_t) - sizeof(uint8_t)) /
      (sizeof(uint8_t) + sizeof(uint32_t) + (send_md5sum ? MD5_HASH_BYTES : 0)));
 
  auto p = std::make_unique<Packet>(this, send_md5sum ? PacketContentType::ClientInfoExternalIDMD5 : PacketContentType::ClientInfoExternalID, TCP_MTU);
  p->Send_uint8((uint8_t)cv->size());
 
  for (const auto &ci : *cv) {
    p->Send_uint8((uint8_t)ci->type);
    p->Send_uint32(ci->unique_id);
    if (!send_md5sum) continue;
    p->Send_bytes(ci->md5sum);
  }
 
  this->SendPacket(std::move(p));
 
  for (auto &ci : *cv) {
    bool found = false;
    for (const auto &ci2 : this->infos) {
      if (ci->type == ci2->type && ci->unique_id == ci2->unique_id &&
          (!send_md5sum || ci->md5sum == ci2->md5sum)) {
        found = true;
        break;
      }
    }
    if (!found) {
      this->infos.push_back(std::move(ci));
    }
  }
}

void ClientNetworkContentSocketHandler::DownloadSelectedContent(uint &files, uint &bytes, bool fallback)
{
  bytes = 0;
 
  ContentIDList content;
  for (const auto &ci : this->infos) {
    if (!ci->IsSelected() || ci->state == ContentInfo::State::AlreadyHere) continue;
 
    content.push_back(ci->id);
    bytes += ci->filesize;
  }
 
  files = (uint)content.size();
 
  /* If there's nothing to download, do nothing. */
  if (files == 0) return;
 
  this->is_cancelled = false;
 
  if (fallback) {
    this->DownloadSelectedContentFallback(content);
  } else {
    this->DownloadSelectedContentHTTP(content);
  }
}

void ClientNetworkContentSocketHandler::DownloadSelectedContentHTTP(const ContentIDList &content)
{
  std::string content_request;
  for (const ContentID &id : content) {
    format_append(content_request, "{}\n", id);
  }
 
  this->http_response_index = -1;
 
  NetworkHTTPSocketHandler::Connect(NetworkContentMirrorUriString(), this, std::move(content_request));
}

void ClientNetworkContentSocketHandler::DownloadSelectedContentFallback(const ContentIDList &content)
{
  uint count = (uint)content.size();
  const ContentID *content_ids = content.data();
  this->Connect();
 
  while (count > 0) {
    /* We can "only" send a limited number of IDs in a single packet.
     * A packet begins with the packet size and a byte for the type.
     * Then this packet adds a uint16_t for the count in this packet.
     * The rest of the packet can be used for the IDs. */
    uint p_count = std::min<uint>(count, (TCP_MTU - sizeof(PacketSize) - sizeof(uint8_t) - sizeof(uint16_t)) / sizeof(uint32_t));
 
    auto p = std::make_unique<Packet>(this, PacketContentType::ClientContent, TCP_MTU);
    p->Send_uint16(p_count);
 
    for (uint i = 0; i < p_count; i++) {
      p->Send_uint32(content_ids[i]);
    }
 
    this->SendPacket(std::move(p));
    count -= p_count;
    content_ids += p_count;
  }
}

static std::string GetFullFilename(const ContentInfo &ci, bool compressed)
{
  Subdirectory dir = GetContentInfoSubDir(ci.type);
  if (dir == Subdirectory::None) return {};
 
  std::string buf = FioGetDirectory(Searchpath::AutodownloadDir, dir);
  buf += ci.filename;
  buf += compressed ? ".tar.gz" : ".tar";
 
  return buf;
}

static bool GunzipFile(const ContentInfo &ci)
{
#if defined(WITH_ZLIB)
  bool ret = true;
 
  /* Need to open the file with fopen() to support non-ASCII on Windows. */
  auto ftmp = FileHandle::Open(GetFullFilename(ci, true), "rb");
  if (!ftmp.has_value()) return false;
  /* Duplicate the handle, and close the FILE*, to avoid double-closing the handle later. */
  int fdup = dup(fileno(*ftmp));
  gzFile fin = gzdopen(fdup, "rb");
  ftmp.reset();
 
  auto fout = FileHandle::Open(GetFullFilename(ci, false), "wb");
 
  if (fin == nullptr || !fout.has_value()) {
    ret = false;
  } else {
    uint8_t buff[8192];
    for (;;) {
      int read = gzread(fin, buff, sizeof(buff));
      if (read == 0) {
        /* If gzread() returns 0, either the end-of-file has been
         * reached or an underlying read error has occurred.
         *
         * gzeof() can't be used, because:
         * 1.2.5 - it is safe, 1 means 'everything was OK'
         * 1.2.3.5, 1.2.4 - 0 or 1 is returned 'randomly'
         * 1.2.3.3 - 1 is returned for truncated archive
         *
         * So we use gzerror(). When proper end of archive
         * has been reached, then:
         * errnum == Z_STREAM_END in 1.2.3.3,
         * errnum == 0 in 1.2.4 and 1.2.5 */
        int errnum;
        gzerror(fin, &errnum);
        if (errnum != 0 && errnum != Z_STREAM_END) ret = false;
        break;
      }
      if (read < 0 || static_cast<size_t>(read) != fwrite(buff, 1, read, *fout)) {
        /* If gzread() returns -1, there was an error in archive */
        ret = false;
        break;
      }
      /* DO NOT DO THIS! It will fail to detect broken archive with 1.2.3.3!
       * if (read < sizeof(buff)) break; */
    }
  }
 
  if (fin != nullptr) {
    gzclose(fin);
  } else if (fdup != -1) {
    /* Failing gzdopen does not close the passed file descriptor. */
    close(fdup);
  }
 
  return ret;
#else
  NOT_REACHED();
#endif /* defined(WITH_ZLIB) */
}
 
bool ClientNetworkContentSocketHandler::ReceiveServerContent(Packet &p)
{
  if (!this->cur_file.has_value()) {
    /* When we haven't opened a file this must be our first packet with metadata. */
    this->cur_info = std::make_unique<ContentInfo>();
    this->cur_info->type     = (ContentType)p.Recv_uint8();
    this->cur_info->id       = (ContentID)p.Recv_uint32();
    this->cur_info->filesize = p.Recv_uint32();
    this->cur_info->filename = p.Recv_string(NETWORK_CONTENT_FILENAME_LENGTH);
 
    if (!this->BeforeDownload()) {
      this->CloseConnection();
      return false;
    }
  } else {
    /* We have a file opened, thus are downloading internal content */
    ssize_t to_read = p.RemainingBytesToTransfer();
    auto write_to_disk = [this](std::span<const uint8_t> buffer) {
      return fwrite(buffer.data(), 1, buffer.size(), *this->cur_file);
    };
    if (to_read != 0 && p.TransferOut(write_to_disk) != to_read) {
      CloseWindowById(WindowClass::NetworkStatus, NetworkStatusWindowNumber::ContentDownload);
      ShowErrorMessage(
        GetEncodedString(STR_CONTENT_ERROR_COULD_NOT_DOWNLOAD),
        GetEncodedString(STR_CONTENT_ERROR_COULD_NOT_DOWNLOAD_FILE_NOT_WRITABLE),
        WarningLevel::Error);
      this->CloseConnection();
      this->cur_file.reset();
 
      return false;
    }
 
    this->OnDownloadProgress(*this->cur_info, (int)to_read);
 
    if (to_read == 0) this->AfterDownload();
  }
 
  return true;
}

bool ClientNetworkContentSocketHandler::BeforeDownload()
{
  if (!this->cur_info->IsValid()) {
    this->cur_info.reset();
    return false;
  }
 
  if (this->cur_info->filesize != 0) {
    /* The filesize is > 0, so we are going to download it */
    std::string filename = GetFullFilename(*this->cur_info, true);
    if (filename.empty() || !(this->cur_file = FileHandle::Open(filename, "wb")).has_value()) {
      /* Unless that fails of course... */
      CloseWindowById(WindowClass::NetworkStatus, NetworkStatusWindowNumber::ContentDownload);
      ShowErrorMessage(
        GetEncodedString(STR_CONTENT_ERROR_COULD_NOT_DOWNLOAD),
        GetEncodedString(STR_CONTENT_ERROR_COULD_NOT_DOWNLOAD_FILE_NOT_WRITABLE),
        WarningLevel::Error);
      return false;
    }
  }
  return true;
}

void ClientNetworkContentSocketHandler::AfterDownload()
{
  /* We read nothing; that's our marker for end-of-stream.
   * Now gunzip the tar and make it known. */
  this->cur_file.reset();
 
  if (GunzipFile(*this->cur_info)) {
    FioRemove(GetFullFilename(*this->cur_info, true));
 
    Subdirectory sd = GetContentInfoSubDir(this->cur_info->type);
    if (sd == Subdirectory::None) NOT_REACHED();
 
    TarScanner ts;
    std::string fname = GetFullFilename(*this->cur_info, false);
    ts.AddFile(sd, fname);
 
    if (this->cur_info->type == ContentType::BaseMusic) {
      /* Music can't be in a tar. So extract the tar! */
      ExtractTar(fname, Subdirectory::Baseset);
      FioRemove(fname);
    }
 
#ifdef __EMSCRIPTEN__
    EM_ASM(if (window["openttd_syncfs"]) openttd_syncfs());
#endif
 
    this->OnDownloadComplete(this->cur_info->id);
  } else {
    ShowErrorMessage(GetEncodedString(STR_CONTENT_ERROR_COULD_NOT_EXTRACT), {}, WarningLevel::Error);
  }
}
 
bool ClientNetworkContentSocketHandler::IsCancelled() const
{
  return this->is_cancelled;
}
 
/* Also called to just clean up the mess. */
void ClientNetworkContentSocketHandler::OnFailure()
{
  this->http_response.clear();
  this->http_response.shrink_to_fit();
  this->http_response_index = -2;
 
  if (this->cur_file.has_value()) {
    this->OnDownloadProgress(*this->cur_info, -1);
 
    this->cur_file.reset();
  }
 
  /* If we fail, download the rest via the 'old' system. */
  if (!this->is_cancelled) {
    uint files, bytes;
 
    this->DownloadSelectedContent(files, bytes, true);
  }
}
 
void ClientNetworkContentSocketHandler::OnReceiveData(std::unique_ptr<char[]> data, size_t length)
{
  assert(data.get() == nullptr || length != 0);
 
  /* Ignore any latent data coming from a connection we closed. */
  if (this->http_response_index == -2) {
    return;
  }
 
  if (this->http_response_index == -1) {
    if (data != nullptr) {
      /* Append the rest of the response. */
      this->http_response.insert(this->http_response.end(), data.get(), data.get() + length);
      return;
    } else {
      /* Make sure the response is properly terminated. */
      this->http_response.push_back('\0');
 
      /* And prepare for receiving the rest of the data. */
      this->http_response_index = 0;
    }
  }
 
  if (data != nullptr) {
    /* We have data, so write it to the file. */
    if (fwrite(data.get(), 1, length, *this->cur_file) != length) {
      /* Writing failed somehow, let try via the old method. */
      this->OnFailure();
    } else {
      /* Just received the data. */
      this->OnDownloadProgress(*this->cur_info, (int)length);
    }
 
    /* Nothing more to do now. */
    return;
  }
 
  if (this->cur_file.has_value()) {
    /* We've finished downloading a file. */
    this->AfterDownload();
  }
 
  if ((uint)this->http_response_index >= this->http_response.size()) {
    /* It's not a real failure, but if there's
     * nothing more to download it helps with
     * cleaning up the stuff we allocated. */
    this->OnFailure();
    return;
  }
 
  /* When we haven't opened a file this must be our first packet with metadata. */
  this->cur_info = std::make_unique<ContentInfo>();
 
  try {
    for (;;) {
      std::string_view buffer{this->http_response.data(), this->http_response.size()};
      buffer.remove_prefix(this->http_response_index);
      auto len = buffer.find('\n');
      if (len == std::string_view::npos) throw std::exception{};
      /* Update the index for the next one */
      this->http_response_index += static_cast<int>(len + 1);
 
      StringConsumer consumer{buffer.substr(0, len)};
 
      /* Read the ID */
      this->cur_info->id = static_cast<ContentID>(consumer.ReadIntegerBase<uint>(10));
      if (!consumer.ReadIf(",")) throw std::exception{};
 
      /* Read the type */
      this->cur_info->type = static_cast<ContentType>(consumer.ReadIntegerBase<uint>(10));
      if (!consumer.ReadIf(",")) throw std::exception{};
 
      /* Read the file size */
      this->cur_info->filesize = consumer.ReadIntegerBase<uint32_t>(10);
      if (!consumer.ReadIf(",")) throw std::exception{};
 
      /* Read the URL */
      auto url = consumer.GetLeftData();
 
      /* Is it a fallback URL? If so, just continue with the next one. */
      if (consumer.ReadIf("ottd")) {
        /* Have we gone through all lines? */
        if (static_cast<size_t>(this->http_response_index) >= this->http_response.size()) throw std::exception{};
        continue;
      }
 
      consumer.SkipUntilChar('/', StringConsumer::KEEP_SEPARATOR);
      std::string_view filename;
      /* Skip all but the last part. There must be at least one / though */
      do {
        if (!consumer.ReadIf("/")) throw std::exception{};
        filename = consumer.ReadUntilChar('/', StringConsumer::KEEP_SEPARATOR);
      } while (consumer.AnyBytesLeft());
 
      /* Remove the extension from the string. */
      for (uint i = 0; i < 2; i++) {
        auto pos = filename.find_last_of('.');
        if (pos == std::string::npos) throw std::exception{};
        filename = filename.substr(0, pos);
      }
 
      /* Copy the string, without extension, to the filename. */
      this->cur_info->filename = filename;
 
      /* Request the next file. */
      if (!this->BeforeDownload()) throw std::exception{};
 
      NetworkHTTPSocketHandler::Connect(url, this);
      break;
    }
  } catch (const std::exception&) {
    this->OnFailure();
  }
}

class NetworkContentConnecter : public TCPConnecter {
public:
  NetworkContentConnecter(std::string_view connection_string) : TCPConnecter(connection_string, NETWORK_CONTENT_SERVER_PORT) {}
 
  void OnFailure() override
  {
    _network_content_client.is_connecting = false;
    _network_content_client.OnConnect(false);
  }
 
  void OnConnect(SOCKET s) override
  {
    assert(_network_content_client.sock == INVALID_SOCKET);
    _network_content_client.last_activity = std::chrono::steady_clock::now();
    _network_content_client.is_connecting = false;
    _network_content_client.sock = s;
    _network_content_client.Reopen();
    _network_content_client.OnConnect(true);
  }
};

void ClientNetworkContentSocketHandler::Connect()
{
  if (this->sock != INVALID_SOCKET || this->is_connecting) return;
 
  this->is_cancelled = false;
  this->is_connecting = true;
 
  TCPConnecter::Create<NetworkContentConnecter>(NetworkContentServerConnectionString());
}

NetworkRecvStatus ClientNetworkContentSocketHandler::CloseConnection([[maybe_unused]] bool error)
{
  NetworkContentSocketHandler::CloseConnection();
 
  if (this->sock == INVALID_SOCKET) return NetworkRecvStatus::Okay;
 
  this->CloseSocket();
  this->OnDisconnect();
 
  return NetworkRecvStatus::Okay;
}

void ClientNetworkContentSocketHandler::Cancel(void)
{
  this->is_cancelled = true;
  this->CloseConnection();
}

void ClientNetworkContentSocketHandler::SendReceive()
{
  if (this->sock == INVALID_SOCKET || this->is_connecting) return;
 
  /* Close the connection to the content server after inactivity; there can still be downloads pending via HTTP. */
  if (std::chrono::steady_clock::now() > this->last_activity + IDLE_TIMEOUT) {
    this->CloseConnection();
    return;
  }
 
  if (this->CanSendReceive()) {
    if (this->ReceivePackets()) {
      /* Only update activity once a packet is received, instead of every time we try it. */
      this->last_activity = std::chrono::steady_clock::now();
    }
  }
 
  this->SendPackets();
}

static constexpr auto CONTENT_QUEUE_TIMEOUT = std::chrono::milliseconds(100);

static TimeoutTimer<TimerWindow> _request_queue_timeout = {CONTENT_QUEUE_TIMEOUT, []() {
  _network_content_client.RequestQueuedContentInfo();
}};

void ClientNetworkContentSocketHandler::DownloadContentInfo(ContentID cid)
{
  /* When we tried to download it already, don't try again */
  if (std::ranges::find(this->requested, cid) != this->requested.end()) return;
 
  this->requested.push_back(cid);
  this->queued.push_back(cid);
  _request_queue_timeout.Reset();
}

void ClientNetworkContentSocketHandler::RequestQueuedContentInfo()
{
  if (this->queued.empty()) return;
 
  /* Wait until we've briefly stopped receiving data (which will contain more content) before making the request. */
  if (std::chrono::steady_clock::now() <= this->last_activity + CONTENT_QUEUE_TIMEOUT) {
    _request_queue_timeout.Reset();
    return;
  }
 
  /* Move the queue locally so more ids can be queued for later. */
  ContentIDList queue;
  queue.swap(this->queued);
 
  /* Remove ids that have since been received since the request was queued. */
  queue.erase(std::remove_if(std::begin(queue), std::end(queue), [this](ContentID content_id) {
    return std::ranges::find(this->infos, content_id, &ContentInfo::id) != std::end(this->infos);
  }), std::end(queue));
 
  this->RequestContentList(queue);
}

ContentInfo *ClientNetworkContentSocketHandler::GetContent(ContentID cid) const
{
  for (const auto &ci : this->infos) {
    if (ci->id == cid) return ci.get();
  }
  return nullptr;
}
 

void ClientNetworkContentSocketHandler::Select(ContentID cid)
{
  ContentInfo *ci = this->GetContent(cid);
  if (ci == nullptr || ci->state != ContentInfo::State::Unselected) return;
 
  ci->state = ContentInfo::State::Selected;
  this->CheckDependencyState(*ci);
}

void ClientNetworkContentSocketHandler::Unselect(ContentID cid)
{
  ContentInfo *ci = this->GetContent(cid);
  if (ci == nullptr || !ci->IsSelected()) return;
 
  ci->state = ContentInfo::State::Unselected;
  this->CheckDependencyState(*ci);
}

void ClientNetworkContentSocketHandler::SelectAll()
{
  for (const auto &ci : this->infos) {
    if (ci->state == ContentInfo::State::Unselected) {
      ci->state = ContentInfo::State::Selected;
      this->CheckDependencyState(*ci);
    }
  }
}

void ClientNetworkContentSocketHandler::SelectUpgrade()
{
  for (const auto &ci : this->infos) {
    if (ci->state == ContentInfo::State::Unselected && ci->upgrade) {
      ci->state = ContentInfo::State::Selected;
      this->CheckDependencyState(*ci);
    }
  }
}

void ClientNetworkContentSocketHandler::UnselectAll()
{
  for (const auto &ci : this->infos) {
    if (ci->IsSelected() && ci->state != ContentInfo::State::AlreadyHere) ci->state = ContentInfo::State::Unselected;
  }
}

void ClientNetworkContentSocketHandler::ToggleSelectedState(const ContentInfo &ci)
{
  switch (ci.state) {
    case ContentInfo::State::Selected:
    case ContentInfo::State::Autoselected:
      this->Unselect(ci.id);
      break;
 
    case ContentInfo::State::Unselected:
      this->Select(ci.id);
      break;
 
    default:
      break;
  }
}

void ClientNetworkContentSocketHandler::ReverseLookupDependency(ConstContentVector &parents, const ContentInfo &child) const
{
  auto range = this->reverse_dependency_map.equal_range(child.id);
 
  for (auto iter = range.first; iter != range.second; ++iter) {
    parents.push_back(GetContent(iter->second));
  }
}

void ClientNetworkContentSocketHandler::ReverseLookupTreeDependency(ConstContentVector &tree, const ContentInfo *child) const
{
  tree.push_back(child);
 
  /* First find all direct parents. We can't use the "normal" iterator as
   * we are including stuff into the vector and as such the vector's data
   * store can be reallocated (and thus move), which means our iterating
   * pointer gets invalid. So fall back to the indices. */
  for (size_t i = 0; i < tree.size(); i++) {
    ConstContentVector parents;
    this->ReverseLookupDependency(parents, *tree[i]);
 
    for (const ContentInfo *ci : parents) {
      include(tree, ci);
    }
  }
}

void ClientNetworkContentSocketHandler::CheckDependencyState(const ContentInfo &ci)
{
  if (ci.IsSelected() || ci.state == ContentInfo::State::AlreadyHere) {
    /* Selection is easy; just walk all children and set the
     * autoselected state. That way we can see what we automatically
     * selected and thus can unselect when a dependency is removed. */
    for (auto &dependency : ci.dependencies) {
      ContentInfo *c = this->GetContent(dependency);
      if (c == nullptr) {
        this->DownloadContentInfo(dependency);
      } else if (c->state == ContentInfo::State::Unselected) {
        c->state = ContentInfo::State::Autoselected;
        this->CheckDependencyState(*c);
      }
    }
    return;
  }
 
  if (ci.state != ContentInfo::State::Unselected) return;
 
  /* For unselection we need to find the parents of us. We need to
   * unselect them. After that we unselect all children that we
   * depend on and are not used as dependency for us, but only when
   * we automatically selected them. */
  ConstContentVector parents;
  this->ReverseLookupDependency(parents, ci);
  for (const ContentInfo *c : parents) {
    if (!c->IsSelected()) continue;
 
    this->Unselect(c->id);
  }
 
  for (auto &dependency : ci.dependencies) {
    const ContentInfo *c = this->GetContent(dependency);
    if (c == nullptr) {
      DownloadContentInfo(dependency);
      continue;
    }
    if (c->state != ContentInfo::State::Autoselected) continue;
 
    /* Only unselect when WE are the only parent. */
    parents.clear();
    this->ReverseLookupDependency(parents, *c);
 
    /* First check whether anything depends on us */
    int sel_count = 0;
    bool force_selection = false;
    for (const ContentInfo *parent_ci : parents) {
      if (parent_ci->IsSelected()) sel_count++;
      if (parent_ci->state == ContentInfo::State::Selected) force_selection = true;
    }
    if (sel_count == 0) {
      /* Nothing depends on us */
      this->Unselect(c->id);
      continue;
    }
    /* Something manually selected depends directly on us */
    if (force_selection) continue;
 
    /* "Flood" search to find all items in the dependency graph*/
    parents.clear();
    this->ReverseLookupTreeDependency(parents, c);
 
    /* Is there anything that is "force" selected?, if so... we're done. */
    for (const ContentInfo *parent_ci : parents) {
      if (parent_ci->state != ContentInfo::State::Selected) continue;
 
      force_selection = true;
      break;
    }
 
    /* So something depended directly on us */
    if (force_selection) continue;
 
    /* Nothing depends on us, mark the whole graph as unselected.
     * After that's done run over them once again to test their children
     * to unselect. Don't do it immediately because it'll do exactly what
     * we're doing now. */
    for (const ContentInfo *parent : parents) {
      if (parent->state == ContentInfo::State::Autoselected) this->Unselect(parent->id);
    }
    for (const ContentInfo *parent : parents) {
      this->CheckDependencyState(*this->GetContent(parent->id));
    }
  }
}

void ClientNetworkContentSocketHandler::Clear()
{
  this->infos.clear();
  this->requested.clear();
  this->queued.clear();
  this->reverse_dependency_map.clear();
}
 
/*** CALLBACK ***/
 
void ClientNetworkContentSocketHandler::OnConnect(bool success)
{
  for (size_t i = 0; i < this->callbacks.size(); /* nothing */) {
    ContentCallback *cb = this->callbacks[i];
    /* the callback may remove itself from this->callbacks */
    cb->OnConnect(success);
    if (i != this->callbacks.size() && this->callbacks[i] == cb) i++;
  }
}
 
void ClientNetworkContentSocketHandler::OnDisconnect()
{
  for (size_t i = 0; i < this->callbacks.size(); /* nothing */) {
    ContentCallback *cb = this->callbacks[i];
    cb->OnDisconnect();
    if (i != this->callbacks.size() && this->callbacks[i] == cb) i++;
  }
}
 
void ClientNetworkContentSocketHandler::OnReceiveContentInfo(const ContentInfo &ci)
{
  for (size_t i = 0; i < this->callbacks.size(); /* nothing */) {
    ContentCallback *cb = this->callbacks[i];
    /* the callback may add items and/or remove itself from this->callbacks */
    cb->OnReceiveContentInfo(ci);
    if (i != this->callbacks.size() && this->callbacks[i] == cb) i++;
  }
}
 
void ClientNetworkContentSocketHandler::OnDownloadProgress(const ContentInfo &ci, int bytes)
{
  for (size_t i = 0; i < this->callbacks.size(); /* nothing */) {
    ContentCallback *cb = this->callbacks[i];
    cb->OnDownloadProgress(ci, bytes);
    if (i != this->callbacks.size() && this->callbacks[i] == cb) i++;
  }
}
 
void ClientNetworkContentSocketHandler::OnDownloadComplete(ContentID cid)
{
  ContentInfo *ci = this->GetContent(cid);
  if (ci != nullptr) {
    ci->state = ContentInfo::State::AlreadyHere;
  }
 
  for (size_t i = 0; i < this->callbacks.size(); /* nothing */) {
    ContentCallback *cb = this->callbacks[i];
    /* the callback may remove itself from this->callbacks */
    cb->OnDownloadComplete(cid);
    if (i != this->callbacks.size() && this->callbacks[i] == cb) i++;
  }
}