Rim/t7x
Rim/t7x
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Introduce sub-protocols

Browse Source
This commit is contained in:
momo5502 2023-04-22 09:13:03 +02:00
parent ff70b3e1c5
commit 6fecdeb68d
5 changed files with 492 additions and 481 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/client/component/getinfo.cpp
View File

@ -110,6 +110,7 @@ namespace getinfo
info.set("bots", std::to_string(get_bot_count())); info.set("bots", std::to_string(get_bot_count()));
info.set("sv_maxclients", std::to_string(get_max_client_count())); info.set("sv_maxclients", std::to_string(get_max_client_count()));
info.set("protocol", std::to_string(PROTOCOL)); info.set("protocol", std::to_string(PROTOCOL));
info.set("sub_protocol", std::to_string(SUB_PROTOCOL));
info.set("playmode", std::to_string(game::Com_SessionMode_GetMode())); info.set("playmode", std::to_string(game::Com_SessionMode_GetMode()));
info.set("gamemode", std::to_string(Com_SessionMode_GetGameMode())); info.set("gamemode", std::to_string(Com_SessionMode_GetGameMode()));
info.set("sv_running", std::to_string(game::is_server_running())); info.set("sv_running", std::to_string(game::is_server_running()));

8
src/client/component/party.cpp
View File

@ -157,6 +157,14 @@ namespace party
return; return;
} }
const auto sub_protocol = atoi(info.get("sub_protocol").data());
if (sub_protocol != SUB_PROTOCOL && sub_protocol != (SUB_PROTOCOL - 1))
{
const auto str = "Invalid sub-protocol.";
printf("%s\n", str);
return;
}
const auto gamename = info.get("gamename"); const auto gamename = info.get("gamename");
if (gamename != "T7"s) if (gamename != "T7"s)
{ {

304
src/client/component/server_list.cpp
View File

@ -1,164 +1,164 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "loader/component_loader.hpp" #include "loader/component_loader.hpp"
#include "server_list.hpp" #include "server_list.hpp"
#include "game/game.hpp" #include "game/game.hpp"
#include <utils/string.hpp> #include <utils/string.hpp>
#include <utils/concurrency.hpp> #include <utils/concurrency.hpp>
#include <utils/hook.hpp> #include <utils/hook.hpp>
#include "network.hpp" #include "network.hpp"
#include "scheduler.hpp" #include "scheduler.hpp"
namespace server_list namespace server_list
{ {
namespace namespace
{ {
utils::hook::detour lua_serverinfo_to_table_hook; utils::hook::detour lua_serverinfo_to_table_hook;
struct state struct state
{ {
game::netadr_t address{}; game::netadr_t address{};
bool requesting{false}; bool requesting{false};
std::chrono::high_resolution_clock::time_point query_start{}; std::chrono::high_resolution_clock::time_point query_start{};
callback callback{}; callback callback{};
}; };
utils::concurrency::container<state> master_state; utils::concurrency::container<state> master_state;
void handle_server_list_response(const game::netadr_t& target, void handle_server_list_response(const game::netadr_t& target,
const network::data_view& data, state& s) const network::data_view& data, state& s)
{ {
if (!s.requesting || s.address != target) if (!s.requesting || s.address != target)
{ {
return; return;
} }
s.requesting = false; s.requesting = false;
const auto callback = std::move(s.callback); const auto callback = std::move(s.callback);
std::optional<size_t> start{}; std::optional<size_t> start{};
for (size_t i = 0; i + 6 < data.size(); ++i) for (size_t i = 0; i + 6 < data.size(); ++i)
{ {
if (data[i + 6] == '\\') if (data[i + 6] == '\\')
{ {
start.emplace(i); start.emplace(i);
break; break;
} }
} }
if (!start.has_value()) if (!start.has_value())
{ {
callback(true, {}); callback(true, {});
return; return;
} }
std::unordered_set<game::netadr_t> result{}; std::unordered_set<game::netadr_t> result{};
for (auto i = start.value(); i + 6 < data.size(); i += 7) for (auto i = start.value(); i + 6 < data.size(); i += 7)
{ {
if (data[i + 6] != '\\') if (data[i + 6] != '\\')
{ {
break; break;
} }
game::netadr_t address{}; game::netadr_t address{};
address.type = game::NA_RAWIP; address.type = game::NA_RAWIP;
address.localNetID = game::NS_CLIENT1; address.localNetID = game::NS_CLIENT1;
memcpy(&address.ipv4.a, data.data() + i + 0, 4); memcpy(&address.ipv4.a, data.data() + i + 0, 4);
memcpy(&address.port, data.data() + i + 4, 2); memcpy(&address.port, data.data() + i + 4, 2);
address.port = ntohs(address.port); address.port = ntohs(address.port);
result.emplace(address); result.emplace(address);
} }
callback(true, result); callback(true, result);
} }
void lua_serverinfo_to_table_stub(game::hks::lua_State* state, game::ServerInfo serverInfo, int index) void lua_serverinfo_to_table_stub(game::hks::lua_State* state, game::ServerInfo serverInfo, int index)
{ {
lua_serverinfo_to_table_hook.invoke(state, serverInfo, index); lua_serverinfo_to_table_hook.invoke(state, serverInfo, index);
if (state) if (state)
{ {
auto botCount = atoi(game::Info_ValueForKey(serverInfo.tags, "bots")); auto botCount = atoi(game::Info_ValueForKey(serverInfo.tags, "bots"));
game::Lua_SetTableInt("botCount", botCount, state); game::Lua_SetTableInt("botCount", botCount, state);
} }
} }
} }
bool get_master_server(game::netadr_t& address) bool get_master_server(game::netadr_t& address)
{ {
address = network::address_from_string("server.boiii.re:20810"); address = network::address_from_string("server.boiii.re:20810");
return address.type != game::NA_BAD; return address.type != game::NA_BAD;
} }
void request_servers(callback callback) void request_servers(callback callback)
{ {
master_state.access([&callback](state& s) master_state.access([&callback](state& s)
{ {
game::netadr_t addr{}; game::netadr_t addr{};
if (!get_master_server(addr)) if (!get_master_server(addr))
{ {
return; return;
} }
s.requesting = true; s.requesting = true;
s.address = addr; s.address = addr;
s.callback = std::move(callback); s.callback = std::move(callback);
s.query_start = std::chrono::high_resolution_clock::now(); s.query_start = std::chrono::high_resolution_clock::now();
network::send(s.address, "getservers", utils::string::va("T7 %i full empty", PROTOCOL)); network::send(s.address, "getservers", utils::string::va("T7 %i full empty", PROTOCOL));
}); });
} }
struct component final : client_component struct component final : client_component
{ {
void post_unpack() override void post_unpack() override
{ {
network::on("getServersResponse", [](const game::netadr_t& target, const network::data_view& data) network::on("getServersResponse", [](const game::netadr_t& target, const network::data_view& data)
{ {
master_state.access([&](state& s) master_state.access([&](state& s)
{ {
handle_server_list_response(target, data, s); handle_server_list_response(target, data, s);
}); });
}); });
scheduler::loop([] scheduler::loop([]
{ {
master_state.access([](state& s) master_state.access([](state& s)
{ {
if (!s.requesting) if (!s.requesting)
{ {
return; return;
} }
const auto now = std::chrono::high_resolution_clock::now(); const auto now = std::chrono::high_resolution_clock::now();
if ((now - s.query_start) < 2s) if ((now - s.query_start) < 2s)
{ {
return; return;
} }
s.requesting = false; s.requesting = false;
s.callback(false, {}); s.callback(false, {});
s.callback = {}; s.callback = {};
}); });
}, scheduler::async, 200ms); }, scheduler::async, 200ms);
lua_serverinfo_to_table_hook.create(0x141F1FD10_g, lua_serverinfo_to_table_stub); lua_serverinfo_to_table_hook.create(0x141F1FD10_g, lua_serverinfo_to_table_stub);
} }
void pre_destroy() override void pre_destroy() override
{ {
master_state.access([](state& s) master_state.access([](state& s)
{ {
s.requesting = false; s.requesting = false;
s.callback = {}; s.callback = {};
}); });
} }
}; };
} }
REGISTER_COMPONENT(server_list::component) REGISTER_COMPONENT(server_list::component)

1
src/client/game/structs.hpp
View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#define PROTOCOL 4 #define PROTOCOL 4
#define SUB_PROTOCOL 1
#ifdef __cplusplus #ifdef __cplusplus
namespace game namespace game

659
src/client/steam/interfaces/matchmaking_servers.cpp
View File

@ -1,333 +1,334 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "../steam.hpp" #include "../steam.hpp"
#include "game/game.hpp" #include "game/game.hpp"
#include "component/party.hpp" #include "component/party.hpp"
#include "component/network.hpp" #include "component/network.hpp"
#include "component/server_list.hpp" #include "component/server_list.hpp"
#include <utils/string.hpp> #include <utils/string.hpp>
#include <utils/concurrency.hpp> #include <utils/concurrency.hpp>
namespace steam namespace steam
{ {
namespace namespace
{ {
struct server struct server
{ {
bool handled{false}; bool handled{false};
game::netadr_t address{}; game::netadr_t address{};
gameserveritem_t server_item{}; gameserveritem_t server_item{};
}; };
auto* const internet_request = reinterpret_cast<void*>(1); auto* const internet_request = reinterpret_cast<void*>(1);
using servers = std::vector<server>; using servers = std::vector<server>;
::utils::concurrency::container<servers> queried_servers{}; ::utils::concurrency::container<servers> queried_servers{};
std::atomic<matchmaking_server_list_response*> current_response{}; std::atomic<matchmaking_server_list_response*> current_response{};
gameserveritem_t create_server_item(const game::netadr_t& address, const ::utils::info_string& info, gameserveritem_t create_server_item(const game::netadr_t& address, const ::utils::info_string& info,
const uint32_t ping, const bool success) const uint32_t ping, const bool success)
{ {
gameserveritem_t server{}; const auto sub_protocol = atoi(info.get("sub_protocol").data());
server.m_NetAdr.m_usConnectionPort = address.port;
server.m_NetAdr.m_usQueryPort = address.port; gameserveritem_t server{};
server.m_NetAdr.m_unIP = ntohl(address.addr); server.m_NetAdr.m_usConnectionPort = address.port;
server.m_nPing = static_cast<int>(ping); server.m_NetAdr.m_usQueryPort = address.port;
server.m_bHadSuccessfulResponse = success; server.m_NetAdr.m_unIP = ntohl(address.addr);
server.m_bDoNotRefresh = false; server.m_nPing = static_cast<int>(ping);
::utils::string::copy(server.m_szGameDir, ""); server.m_bHadSuccessfulResponse = success;
::utils::string::copy(server.m_szMap, info.get("mapname").data()); server.m_bDoNotRefresh = false;
::utils::string::copy(server.m_szGameDescription, info.get("description").data()); ::utils::string::copy(server.m_szGameDir, "");
server.m_nAppID = 311210; ::utils::string::copy(server.m_szMap, info.get("mapname").data());
server.m_nPlayers = atoi(info.get("clients").data()); ::utils::string::copy(server.m_szGameDescription, info.get("description").data());
server.m_nMaxPlayers = atoi(info.get("sv_maxclients").data()); server.m_nAppID = (sub_protocol == SUB_PROTOCOL || sub_protocol == (SUB_PROTOCOL - 1)) ? 311210 : 0;
server.m_nBotPlayers = atoi(info.get("bots").data()); server.m_nPlayers = atoi(info.get("clients").data());
server.m_bPassword = info.get("isPrivate") == "1"; server.m_nMaxPlayers = atoi(info.get("sv_maxclients").data());
server.m_bSecure = true; server.m_nBotPlayers = atoi(info.get("bots").data());
server.m_ulTimeLastPlayed = 0; server.m_bPassword = info.get("isPrivate") == "1";
server.m_nServerVersion = 1000; server.m_bSecure = true;
::utils::string::copy(server.m_szServerName, info.get("hostname").data()); server.m_ulTimeLastPlayed = 0;
server.m_nServerVersion = 1000;
const auto playmode = info.get("playmode"); ::utils::string::copy(server.m_szServerName, info.get("hostname").data());
const auto mode = game::eModes(std::atoi(playmode.data()));
const auto playmode = info.get("playmode");
const auto* tags = ::utils::string::va( const auto mode = game::eModes(std::atoi(playmode.data()));
R"(\gametype\%s\dedicated\%s\ranked\false\hardcore\%s\zombies\%s\playerCount\%d\bots\%d\modName\%s\)",
info.get("gametype").data(), const auto* tags = ::utils::string::va(
R"(\gametype\%s\dedicated\%s\ranked\false\hardcore\%s\zombies\%s\playerCount\%d\bots\%d\modName\%s\)",
info.get("gametype").data(),
info.get("dedicated") == "1" ? "true" : "false", info.get("dedicated") == "1" ? "true" : "false",
info.get("hc") == "1" ? "true" : "false", info.get("hc") == "1" ? "true" : "false",
mode == game::MODE_ZOMBIES ? "true" : "false", mode == game::MODE_ZOMBIES ? "true" : "false",
server.m_nPlayers, server.m_nPlayers,
atoi(info.get("bots").data()), atoi(info.get("bots").data()),
info.get("modname").data()); info.get("modname").data());
::utils::string::copy(server.m_szGameTags, tags); ::utils::string::copy(server.m_szGameTags, tags);
server.m_steamID.bits = strtoull(info.get("xuid").data(), nullptr, 16); server.m_steamID.bits = strtoull(info.get("xuid").data(), nullptr, 16);
return server; return server;
} }
void handle_server_respone(const bool success, const game::netadr_t& host, const ::utils::info_string& info, void handle_server_respone(const bool success, const game::netadr_t& host, const ::utils::info_string& info,
const uint32_t ping) const uint32_t ping)
{ {
bool all_handled = false; bool all_handled = false;
std::optional<int> index{}; std::optional<int> index{};
queried_servers.access([&](servers& srvs) queried_servers.access([&](servers& srvs)
{ {
size_t i = 0; size_t i = 0;
for (; i < srvs.size(); ++i) for (; i < srvs.size(); ++i)
{ {
if (srvs[i].address == host) if (srvs[i].address == host)
{ {
break; break;
} }
} }
if (i >= srvs.size()) if (i >= srvs.size())
{ {
return; return;
} }
index = static_cast<int>(i); index = static_cast<int>(i);
auto& srv = srvs[i]; auto& srv = srvs[i];
srv.handled = true; srv.handled = true;
srv.server_item = create_server_item(host, info, ping, success); srv.server_item = create_server_item(host, info, ping, success);
for (const auto& entry : srvs) for (const auto& entry : srvs)
{ {
if (!entry.handled) if (!entry.handled)
{ {
return; return;
} }
} }
all_handled = true; all_handled = true;
}); });
const auto res = current_response.load(); const auto res = current_response.load();
if (!index || !res) if (!index || !res)
{ {
return; return;
} }
if (success) if (success)
{ {
res->ServerResponded(internet_request, *index); res->ServerResponded(internet_request, *index);
} }
else else
{ {
res->ServerFailedToRespond(internet_request, *index); res->ServerFailedToRespond(internet_request, *index);
} }
if (all_handled) if (all_handled)
{ {
res->RefreshComplete(internet_request, eServerResponded); res->RefreshComplete(internet_request, eServerResponded);
} }
} }
void ping_server(const game::netadr_t& server) void ping_server(const game::netadr_t& server)
{ {
party::query_server(server, handle_server_respone); party::query_server(server, handle_server_respone);
} }
} }
void* matchmaking_servers::RequestInternetServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, void* matchmaking_servers::RequestInternetServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters,
matchmaking_server_list_response* pRequestServersResponse) matchmaking_server_list_response* pRequestServersResponse)
{ {
current_response = pRequestServersResponse; current_response = pRequestServersResponse;
server_list::request_servers([](const bool success, const std::unordered_set<game::netadr_t>& s) server_list::request_servers([](const bool success, const std::unordered_set<game::netadr_t>& s)
{ {
const auto res = current_response.load(); const auto res = current_response.load();
if (!res) if (!res)
{ {
return; return;
} }
if (!success) if (!success)
{ {
res->RefreshComplete(internet_request, eServerFailedToRespond); res->RefreshComplete(internet_request, eServerFailedToRespond);
return; return;
} }
if (s.empty()) if (s.empty())
{ {
res->RefreshComplete(internet_request, eNoServersListedOnMasterServer); res->RefreshComplete(internet_request, eNoServersListedOnMasterServer);
return; return;
} }
queried_servers.access([&s](servers& srvs) queried_servers.access([&s](servers& srvs)
{ {
srvs = {}; srvs = {};
srvs.reserve(s.size()); srvs.reserve(s.size());
for (auto& address : s) for (auto& address : s)
{ {
server new_server{}; server new_server{};
new_server.address = address; new_server.address = address;
new_server.server_item = create_server_item(address, {}, 0, false); new_server.server_item = create_server_item(address, {}, 0, false);
srvs.push_back(new_server); srvs.push_back(new_server);
} }
}); });
for (auto& srv : s) for (auto& srv : s)
{ {
ping_server(srv); ping_server(srv);
} }
}); });
return internet_request; return internet_request;
} }
void* matchmaking_servers::RequestLANServerList(unsigned int iApp, void* matchmaking_servers::RequestLANServerList(unsigned int iApp,
matchmaking_server_list_response* pRequestServersResponse) matchmaking_server_list_response* pRequestServersResponse)
{ {
return reinterpret_cast<void*>(2); return reinterpret_cast<void*>(2);
} }
void* matchmaking_servers::RequestFriendsServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, void* matchmaking_servers::RequestFriendsServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters,
matchmaking_server_list_response* pRequestServersResponse) matchmaking_server_list_response* pRequestServersResponse)
{ {
return reinterpret_cast<void*>(3); return reinterpret_cast<void*>(3);
} }
void* matchmaking_servers::RequestFavoritesServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, void* matchmaking_servers::RequestFavoritesServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters,
matchmaking_server_list_response* pRequestServersResponse) matchmaking_server_list_response* pRequestServersResponse)
{ {
return reinterpret_cast<void*>(4); return reinterpret_cast<void*>(4);
} }
void* matchmaking_servers::RequestHistoryServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, void* matchmaking_servers::RequestHistoryServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters,
matchmaking_server_list_response* pRequestServersResponse) matchmaking_server_list_response* pRequestServersResponse)
{ {
return reinterpret_cast<void*>(5); return reinterpret_cast<void*>(5);
} }
void* matchmaking_servers::RequestSpectatorServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters, void* matchmaking_servers::RequestSpectatorServerList(unsigned int iApp, void** ppchFilters, unsigned int nFilters,
matchmaking_server_list_response* pRequestServersResponse) matchmaking_server_list_response* pRequestServersResponse)
{ {
return reinterpret_cast<void*>(6); return reinterpret_cast<void*>(6);
} }
void matchmaking_servers::ReleaseRequest(void* hServerListRequest) void matchmaking_servers::ReleaseRequest(void* hServerListRequest)
{ {
if (internet_request == hServerListRequest) if (internet_request == hServerListRequest)
{ {
current_response = nullptr; current_response = nullptr;
} }
} }
gameserveritem_t* matchmaking_servers::GetServerDetails(void* hRequest, int iServer) gameserveritem_t* matchmaking_servers::GetServerDetails(void* hRequest, int iServer)
{ {
if (internet_request != hRequest) if (internet_request != hRequest)
{ {
return nullptr; return nullptr;
} }
static thread_local gameserveritem_t server_item{}; static thread_local gameserveritem_t server_item{};
return queried_servers.access<gameserveritem_t*>([iServer](const servers& s) -> gameserveritem_t* return queried_servers.access<gameserveritem_t*>([iServer](const servers& s) -> gameserveritem_t* {
{ if (iServer < 0 || static_cast<size_t>(iServer) >= s.size())
if (iServer < 0 || static_cast<size_t>(iServer) >= s.size()) {
{ return nullptr;
return nullptr; }
}
server_item = s[iServer].server_item;
server_item = s[iServer].server_item; return &server_item;
return &server_item; });
}); }
}
void matchmaking_servers::CancelQuery(void* hRequest)
void matchmaking_servers::CancelQuery(void* hRequest) {
{ }
}
void matchmaking_servers::RefreshQuery(void* hRequest)
void matchmaking_servers::RefreshQuery(void* hRequest) {
{ }
}
bool matchmaking_servers::IsRefreshing(void* hRequest)
bool matchmaking_servers::IsRefreshing(void* hRequest) {
{ return false;
return false; }
}
int matchmaking_servers::GetServerCount(void* hRequest)
int matchmaking_servers::GetServerCount(void* hRequest) {
{ if (internet_request != hRequest)
if (internet_request != hRequest) {
{ return 0;
return 0; }
}
return queried_servers.access<int>([](const servers& s)
return queried_servers.access<int>([](const servers& s) {
{ return static_cast<int>(s.size());
return static_cast<int>(s.size()); });
}); }
}
void matchmaking_servers::RefreshServer(void* hRequest, const int iServer)
void matchmaking_servers::RefreshServer(void* hRequest, const int iServer) {
{ if (internet_request != hRequest)
if (internet_request != hRequest) {
{ return;
return; }
}
std::optional<game::netadr_t> address{};
std::optional<game::netadr_t> address{}; queried_servers.access([&](const servers& s)
queried_servers.access([&](const servers& s) {
{ if (iServer < 0 || static_cast<size_t>(iServer) >= s.size())
if (iServer < 0 || static_cast<size_t>(iServer) >= s.size()) {
{ return;
return; }
}
address = s[iServer].address;
address = s[iServer].address; });
});
if (address)
if (address) {
{ ping_server(*address);
ping_server(*address); }
} }
}
void* matchmaking_servers::PingServer(const unsigned int unIP, const unsigned short usPort,
void* matchmaking_servers::PingServer(const unsigned int unIP, const unsigned short usPort, matchmaking_ping_response* pRequestServersResponse)
matchmaking_ping_response* pRequestServersResponse) {
{ auto response = pRequestServersResponse;
auto response = pRequestServersResponse; const auto addr = network::address_from_ip(htonl(unIP), usPort);
const auto addr = network::address_from_ip(htonl(unIP), usPort);
party::query_server(
party::query_server( addr, [response](const bool success, const game::netadr_t& host, const ::utils::info_string& info,
addr, [response](const bool success, const game::netadr_t& host, const ::utils::info_string& info, const uint32_t ping)
const uint32_t ping) {
{ if (success)
if (success) {
{ auto server_item = create_server_item(host, info, ping, success);
auto server_item = create_server_item(host, info, ping, success); response->ServerResponded(server_item);
response->ServerResponded(server_item); }
} else
else {
{ response->ServerFailedToRespond();
response->ServerFailedToRespond(); }
} });
});
return reinterpret_cast<void*>(static_cast<uint64_t>(7 + rand()));
return reinterpret_cast<void*>(static_cast<uint64_t>(7 + rand())); }
}
int matchmaking_servers::PlayerDetails(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse)
int matchmaking_servers::PlayerDetails(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse) {
{ return 0;
return 0; }
}
int matchmaking_servers::ServerRules(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse)
int matchmaking_servers::ServerRules(unsigned int unIP, unsigned short usPort, void* pRequestServersResponse) {
{ return 0;
return 0; }
}
void matchmaking_servers::CancelServerQuery(int hServerQuery)
void matchmaking_servers::CancelServerQuery(int hServerQuery) {
{ }
} }
}