ClientConVars.cpp

Go to the documentation of this file.

#include "Engine/Net/ServerSideClients.hpp"
#include "Hooks/PendingConVarQueries.hpp"
 
#include <VoltMod/Core/Log.hpp>
#include <VoltMod/Core/Slots/Slot.hpp>
#include <VoltMod/Core/Time/Durations.hpp>
#include <VoltMod/Engine/Detours.hpp>
#include <VoltMod/Engine/GameData/Bindings.hpp>
#include <VoltMod/Engine/Interfaces.hpp>
#include <VoltMod/Engine/Net/RecipientFilter.hpp>
#include <VoltMod/Hooks/ClientConVars.hpp>
#include <VoltMod/Unsafe/Hook.hpp>
#include <cstdint>
#include <engine/igameeventsystem.h>
#include <inetchannel.h>
#include <netmessages.pb.h>
#include <networksystem/inetworkmessages.h>
#include <networksystem/netmessage.h>
#include <utility>
 
namespace VoltMod
{
 
static_assert(std::to_underlying(ClientConVarStatus::Answered) == eQueryCvarValueStatus_ValueIntact);
static_assert(std::to_underlying(ClientConVarStatus::NotFound) == eQueryCvarValueStatus_CvarNotFound);
static_assert(std::to_underlying(ClientConVarStatus::NotAConVar) == eQueryCvarValueStatus_NotACvar);
static_assert(std::to_underlying(ClientConVarStatus::Protected) == eQueryCvarValueStatus_CvarProtected);
 
ClientConVars::ClientConVars(Interfaces& interfaces, const Bindings& bindings, SlotEvents& slots)
    : _interfaces(interfaces), _bindings(bindings), _pending(std::make_unique<PendingConVarQueries>())
{
    // A slot transition invalidates requests for its previous occupant.
    _slotListener = slots.Changed += [this](int slot) { _pending->Clear(slot); };
 
    if (Status installed = Install(); !installed)
    {
        _failure = installed.error();
    }
}
 
ClientConVars::~ClientConVars() = default;
 
Status ClientConVars::Available() const
{
    if (_hook)
    {
        return {};
    }
    return std::unexpected(_failure);
}
 
Status ClientConVars::Install()
{
    if (!_interfaces.Engine || !_interfaces.NetworkMessages || !_interfaces.GameEventSystem)
    {
        return std::unexpected(Error::NotReady("engine interfaces unavailable"));
    }
 
    if (!_bindings.ClientSlot)
    {
        return std::unexpected(Error::Unsupported("the ClientSlot offset did not bind"));
    }
 
    INetworkMessageInternal* getCvarValue =
        _interfaces.NetworkMessages->FindNetworkMessagePartial("CSVCMsg_GetCvarValue");
    if (!getCvarValue)
    {
        return std::unexpected(Error::Engine("the engine does not provide CSVCMsg_GetCvarValue"));
    }
 
    const auto onResponse = [this](EngineClient& client, const CNetMessage* message) {
        OnRespondCvarValue(client, *message);
    };
    auto hook = HookVirtual("Client convar response", _bindings.ProcessRespondCvarValue, nullptr, onResponse);
    if (!hook)
    {
        return std::unexpected(hook.error());
    }
 
    _hook = std::move(*hook);
    _getCvarValue = getCvarValue;
    Log::Info("Client convar queries enabled (slot offset {}).", _bindings.ClientSlot.Value());
    return {};
}
 
bool ClientConVars::Query(int slot, std::string_view cvarName, QueryCallback callback)
{
    if (!_hook || !IsValidSlot(slot) || cvarName.empty() || !callback)
    {
        return false;
    }
 
    const double now = Time::MonotonicSeconds();
    _pending->Prune(slot, now);
 
    // Share one request among callbacks for the same convar.
    if (PendingConVarQuery* inFlight = _pending->Find(slot, cvarName))
    {
        inFlight->Callback = std::move(callback);
        return true;
    }
 
    if (_pending->Full(slot))
    {
        return false;
    }
 
    const int cookie = _pending->NextCookie(slot);
    if (cookie < 0 || !Send(slot, cvarName, cookie))
    {
        return false;
    }
 
    _pending->Add(slot, cookie, std::string(cvarName), std::move(callback), now);
    return true;
}
 
size_t ClientConVars::PendingCount(int slot) const
{
    return _pending->Count(slot);
}
 
void ClientConVars::OnServerStartup()
{
    _pending->ClearAll();
}
 
bool ClientConVars::Send(int slot, std::string_view cvarName, int cookie)
{
    // Bots and empty slots have no network channel.
    if (!_interfaces.Engine->GetPlayerNetInfo(CPlayerSlot(slot)))
    {
        return false;
    }
 
    CNetMessage* message = _getCvarValue->AllocateMessage();
    if (!message)
    {
        return false;
    }
 
    auto* request = message->ToPB<CSVCMsg_GetCvarValue>();
    if (!request)
    {
        _interfaces.NetworkMessages->DeallocateNetMessageAbstract(_getCvarValue, message);
        return false;
    }
 
    request->set_cookie(cookie);
    request->set_cvar_name(std::string(cvarName));
 
    SingleRecipientFilter filter(slot);
    _interfaces.GameEventSystem->PostEventAbstract(-1, false, &filter, _getCvarValue, request, 0);
    _interfaces.NetworkMessages->DeallocateNetMessageAbstract(_getCvarValue, message);
    return true;
}
 
void ClientConVars::OnRespondCvarValue(const EngineClient& client, const CNetMessage& message)
{
    // Gamedata supplies the SDK-missing client slot offset; -1 means it did not bind.
    const int slot = ClientSlot(_bindings, &client);
    const auto& msg = *message.ToPB<CCLCMsg_RespondCvarValue>();
 
    if (!IsValidSlot(slot) || !msg.has_cookie() || !msg.has_status_code() || !msg.has_name())
    {
        return;
    }
 
    // Validate every client-controlled field before dispatch.
    const int status = msg.status_code();
    if (!EQueryCvarValueStatus_IsValid(status))
    {
        return;
    }
 
    std::string_view value;
    if (status == std::to_underlying(ClientConVarStatus::Answered))
    {
        if (!msg.has_value() || msg.value().find('\0') != std::string::npos)
        {
            return;
        }
        value = msg.value();
    }
 
    // Remove before callbacks may query the same convar again.
    auto query = _pending->Take(slot, msg.cookie(), msg.name());
    if (query && query->Callback)
    {
        query->Callback(slot, static_cast<ClientConVarStatus>(status), msg.name(), value);
    }
}
 
}  // namespace VoltMod