mirrors/gbe_fork
1
0
Fork 0
mirror of https://github.com/Detanup01/gbe_fork.git synced 2025-09-10 12:03:06 +02:00
Code Activity

Merge pull request #294 from NicknineTheEagle/nn/interfaces

Browse source 
Added legacy interfaces
This commit is contained in:
Detanup01 2025-07-25 13:15:05 +02:00 • committed by GitHub
commit 73df09b7e4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
25 changed files with 1258 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
dll/client_known_interfaces.cpp
View file

@ -54,6 +54,7 @@ extern const std::unordered_set<std::string> client_known_interfaces = {
"SteamFriends017",
"SteamFriends018",
"SteamGameCoordinator001",
"SteamGameServer001", // not present in the current steamclient.dll
"SteamGameServer002",
"SteamGameServer003",
"SteamGameServer004",
@ -182,6 +183,8 @@ extern const std::unordered_set<std::string> client_known_interfaces = {
"STEAMUGC_INTERFACE_VERSION020",
"STEAMUGC_INTERFACE_VERSION021",
"STEAMUNIFIEDMESSAGES_INTERFACE_VERSION001",
"SteamUser001", // not present in the current steamclient.dll
"SteamUser002", // not present in the current steamclient.dll
"SteamUser004",
"SteamUser005",
"SteamUser006",

245
dll/dll.cpp
View file

@ -19,6 +19,7 @@
#include "dll/dll.h"
#include "dll/settings_parser.h"
#include "dll/client_known_interfaces.h"
#include "dll/capicmcallback.h"
static char old_client[128] = STEAMCLIENT_INTERFACE_VERSION; //"SteamClient017";
@ -215,7 +216,19 @@ static void *create_client_interface(const char *ver)
Steam_Client *client_ptr = get_steam_client();
if (strstr(ver, "SteamClient") == ver) {
if (strcmp(ver, "SteamClient006") == 0) {
client_ptr->steamclient_version = atoi(ver + 11);
if (strcmp(ver, "SteamClient001") == 0) {
return static_cast<ISteamClient001 *>(client_ptr);
} else if (strcmp(ver, "SteamClient002") == 0) {
return static_cast<ISteamClient002 *>(client_ptr);
} else if (strcmp(ver, "SteamClient003") == 0) {
return static_cast<ISteamClient003 *>(client_ptr);
} else if (strcmp(ver, "SteamClient004") == 0) {
return static_cast<ISteamClient004 *>(client_ptr);
} else if (strcmp(ver, "SteamClient005") == 0) {
return static_cast<ISteamClient005 *>(client_ptr);
} else if (strcmp(ver, "SteamClient006") == 0) {
return static_cast<ISteamClient006 *>(client_ptr);
} else if (strcmp(ver, "SteamClient007") == 0) {
return static_cast<ISteamClient007 *>(client_ptr);
@ -1325,6 +1338,16 @@ STEAMCLIENT_API void Steam_FreeLastCallback( HSteamPipe hSteamPipe )
SteamAPI_ManualDispatch_FreeLastCallback( hSteamPipe );
}
bool steamclient_get_callback(HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg)
{
return Steam_BGetCallback(hSteamPipe, pCallbackMsg);
}
void steamclient_free_callback(HSteamPipe hSteamPipe)
{
return Steam_FreeLastCallback(hSteamPipe);
}
STEAMCLIENT_API steam_bool Steam_GetAPICallResult( HSteamPipe hSteamPipe, SteamAPICall_t hSteamAPICall, void* pCallback, int cubCallback, int iCallbackExpected, bool* pbFailed )
{
//PRINT_DEBUG("%i %llu %i %i", hSteamPipe, hSteamAPICall, cubCallback, iCallbackExpected);
@ -1379,6 +1402,9 @@ STEAMCLIENT_API void Breakpad_SteamWriteMiniDumpUsingExceptionInfoWithBuildId( i
STEAMCLIENT_API steam_bool Steam_BConnected( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 5)
return 0;
ISteamUser004 *su = reinterpret_cast<ISteamUser004 *>(get_steam_client()->GetISteamUser(hUser, hSteamPipe, "SteamUser004"));
return su->BConnected();
}
@ -1386,6 +1412,9 @@ STEAMCLIENT_API steam_bool Steam_BConnected( HSteamUser hUser, HSteamPipe hSteam
STEAMCLIENT_API steam_bool Steam_BLoggedOn( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 5)
return 0;
ISteamUser004 *su = reinterpret_cast<ISteamUser004 *>(get_steam_client()->GetISteamUser(hUser, hSteamPipe, "SteamUser004"));
return su->BLoggedOn();
}
@ -1399,24 +1428,28 @@ STEAMCLIENT_API steam_bool Steam_BReleaseSteamPipe( HSteamPipe hSteamPipe )
STEAMCLIENT_API HSteamUser Steam_ConnectToGlobalUser( HSteamPipe hSteamPipe )
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steamclient_version = 6;
return get_steam_client()->ConnectToGlobalUser(hSteamPipe);
}
STEAMCLIENT_API HSteamUser Steam_CreateGlobalUser( HSteamPipe *phSteamPipe )
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steamclient_version = 6;
return get_steam_client()->CreateGlobalUser(phSteamPipe);
}
STEAMCLIENT_API HSteamUser Steam_CreateLocalUser( HSteamPipe *phSteamPipe, EAccountType eAccountType )
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steamclient_version = 6;
return get_steam_client()->CreateLocalUser(phSteamPipe, eAccountType);
}
STEAMCLIENT_API HSteamPipe Steam_CreateSteamPipe()
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steamclient_version = 6;
return get_steam_client()->CreateSteamPipe();
}
@ -1453,6 +1486,9 @@ STEAMCLIENT_API steam_bool Steam_GSGetSteam2GetEncryptionKeyToSendToNewClient( v
STEAMCLIENT_API int Steam_GSGetSteamGameConnectToken(HSteamUser hUser, HSteamPipe hSteamPipe, void *pBlob, int cbMaxBlob)
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 5)
return 0;
ISteamUser004 *su = reinterpret_cast<ISteamUser004 *>(get_steam_client()->GetISteamUser(hUser, hSteamPipe, "SteamUser004"));
return su->GetSteamGameConnectToken(pBlob, cbMaxBlob);
}
@ -1557,6 +1593,9 @@ STEAMCLIENT_API steam_bool Steam_GSUpdateStatus( void *phSteamHandle, int cPlaye
STEAMCLIENT_API int Steam_InitiateGameConnection( HSteamUser hUser, HSteamPipe hSteamPipe, void *pBlob, int cbMaxBlob, uint64 steamID, int nGameAppID, uint32 unIPServer, uint16 usPortServer, bool bSecure )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 5)
return 0;
ISteamUser004 *su = reinterpret_cast<ISteamUser004 *>(get_steam_client()->GetISteamUser(hUser, hSteamPipe, "SteamUser004"));
return su->InitiateGameConnection(pBlob, cbMaxBlob, steamID, nGameAppID, unIPServer, usPortServer, bSecure);
}
@ -1582,6 +1621,9 @@ STEAMCLIENT_API steam_bool Steam_IsKnownInterface( const char *pchVersion )
STEAMCLIENT_API void Steam_LogOff( HSteamUser hUser, HSteamPipe hSteamPipe )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 5)
return;
ISteamUser004 *su = reinterpret_cast<ISteamUser004 *>(get_steam_client()->GetISteamUser(hUser, hSteamPipe, "SteamUser004"));
su->LogOff();
}
@ -1589,6 +1631,9 @@ STEAMCLIENT_API void Steam_LogOff( HSteamUser hUser, HSteamPipe hSteamPipe )
STEAMCLIENT_API void Steam_LogOn( HSteamUser hUser, HSteamPipe hSteamPipe, uint64 ulSteamID )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 5)
return;
ISteamUser004 *su = reinterpret_cast<ISteamUser004 *>(get_steam_client()->GetISteamUser(hUser, hSteamPipe, "SteamUser004"));
su->LogOn(ulSteamID);
}
@ -1620,6 +1665,204 @@ STEAMCLIENT_API void Steam_SetLocalIPBinding( uint32 unIP, uint16 usLocalPort )
STEAMCLIENT_API void Steam_TerminateGameConnection( HSteamUser hUser, HSteamPipe hSteamPipe, uint32 unIPServer, uint16 usPortServer )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 5)
return;
ISteamUser004 *su = reinterpret_cast<ISteamUser004 *>(get_steam_client()->GetISteamUser(hUser, hSteamPipe, "SteamUser004"));
su->TerminateGameConnection(unIPServer, usPortServer);
}
// older sdk ----------------------------------------------------------
STEAMCLIENT_API HSteamUser Steam3_ConnectToGlobalInstance()
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steamclient_version = 4;
return get_steam_client()->ConnectToGlobalInstance();
}
STEAMCLIENT_API HSteamUser Steam3_CreateLocalInstance()
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steamclient_version = 4;
return get_steam_client()->CreateLocalInstance();
}
STEAMCLIENT_API void Steam3_ReleaseInstance( HSteamUser hUser )
{
PRINT_DEBUG_ENTRY();
get_steam_client()->ReleaseInstance(hUser);
}
STEAMCLIENT_API steam_bool Steam3_BMainLoop( uint64 time, bool unk )
{
PRINT_DEBUG_ENTRY();
// Bool argument was dropped in SteamClient003 so just ignore it for compatibility.
return get_steam_client()->BMainLoop(time);
}
STEAMCLIENT_API void Steam3_LogOn( HSteamUser hUser, uint64 steamID )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
CSteamID steam_id_struct(steamID);
su->LogOn(&steam_id_struct);
}
STEAMCLIENT_API void Steam3_LogOff( HSteamUser hUser )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
su->LogOff();
}
STEAMCLIENT_API steam_bool Steam3_BLoggedOn( HSteamUser hUser )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return 0;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
return su->BLoggedOn();
}
STEAMCLIENT_API steam_bool Steam3_BConnected( HSteamUser hUser )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return 0;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
return su->BConnected();
}
STEAMCLIENT_API steam_bool Steam3_GSSendLogonRequest( HSteamUser hUser, uint64 steamID )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return 0;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
CSteamID steam_id_struct(steamID);
return su->GSSendLogonRequest(&steam_id_struct);
}
STEAMCLIENT_API steam_bool Steam3_GSSendDisconnect( HSteamUser hUser, uint64 steamID )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return 0;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
CSteamID steam_id_struct(steamID);
return su->GSSendDisconnect(&steam_id_struct);
}
STEAMCLIENT_API steam_bool Steam3_GSSendStatusResponse( HSteamUser hUser, uint64 steamID, int nSecondsConnected, int nSecondsSinceLast )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return 0;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
CSteamID steam_id_struct(steamID);
return su->GSSendStatusResponse(&steam_id_struct, nSecondsConnected, nSecondsSinceLast);
}
STEAMCLIENT_API steam_bool Steam3_GSSetStatus( HSteamUser hUser, int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax, int cBotPlayers, int unGamePort, const char *pchServerName, const char *pchGameDir, const char *pchMapName, const char *pchVersion )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version < 2)
return 0;
if (get_steam_client()->steamclient_version < 4) {
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
return su->GSSetStatus(nAppIdServed, unServerFlags, cPlayers, cPlayersMax, cBotPlayers, unGamePort, pchServerName, pchGameDir, pchMapName, pchVersion);
}
ISteamGameServer001 *gs = reinterpret_cast<ISteamGameServer001 *>(get_steam_client()->GetISteamGameServer(hUser, "SteamGameServer001"));
return gs->Obsolete_GSSetStatus(nAppIdServed, unServerFlags, cPlayers, cPlayersMax, cBotPlayers, unGamePort, pchServerName, pchGameDir, pchMapName, pchVersion);
}
static std::map<HSteamUser, CCAPICMCallBack> capi_cmcallback_map;
STEAMCLIENT_API void Steam3_Init( HSteamUser hUser,
OnLogonSuccessFunc func1,
OnLogonFailureFunc func2,
OnLoggedOffFunc func3,
OnBeginLogonRetryFunc func4,
HandleVACChallengeFunc func5,
GSHandleClientApproveFunc func6,
GSHandleClientDenyFunc func7,
GSHandleClientKickFunc func8 )
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steamclient_version = 2;
ISteamUser002 *su = reinterpret_cast<ISteamUser002 *>(get_steam_client()->GetISteamUser(hUser, "SteamUser002"));
CCAPICMCallBack new_cmcallback(func1, func2, func3, func4, func5, func6, func7, func8);
auto [it, _] = capi_cmcallback_map.insert_or_assign(hUser, new_cmcallback);
su->Init(&it->second, nullptr);
}
STEAMCLIENT_API steam_bool Steam3_GSSendUserConnect( HSteamUser hUser, uint64 steamID, uint32 unIPPublic, uint32 unk )
{
PRINT_DEBUG_ENTRY();
ISteamGameServer001 *gs = reinterpret_cast<ISteamGameServer001 *>(get_steam_client()->GetISteamGameServer(hUser, "SteamGameServer001"));
return gs->GSSendUserConnect(steamID, unIPPublic, unk);
}
STEAMCLIENT_API steam_bool Steam3_GSSendUserDisconnect( HSteamUser hUser, uint64 steamID )
{
PRINT_DEBUG_ENTRY();
ISteamGameServer001 *gs = reinterpret_cast<ISteamGameServer001 *>(get_steam_client()->GetISteamGameServer(hUser, "SteamGameServer001"));
return gs->GSSendUserDisconnect(steamID);
}
STEAMCLIENT_API steam_bool Steam3_GSSendUserStatusResponse( HSteamUser hUser, uint64 steamID, int nSecondsConnected, int nSecondsSinceLast )
{
PRINT_DEBUG_ENTRY();
ISteamGameServer001 *gs = reinterpret_cast<ISteamGameServer001 *>(get_steam_client()->GetISteamGameServer(hUser, "SteamGameServer001"));
return gs->GSSendUserStatusResponse(steamID, nSecondsConnected, nSecondsSinceLast);
}
STEAMCLIENT_API steam_bool Steam3_BGetCallback( HSteamUser hUser, int *piCallback, uint8_t **ppubParam, int *unk )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version != 4)
return 0;
ISteamUser004_old *su = reinterpret_cast<ISteamUser004_old *>(get_steam_client()->GetISteamUser(hUser, "SteamUser004"));
return su->BGetCallback(piCallback, ppubParam, unk);
}
STEAMCLIENT_API void Steam3_FreeLastCallback( HSteamUser hUser )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version != 4)
return;
ISteamUser004_old *su = reinterpret_cast<ISteamUser004_old *>(get_steam_client()->GetISteamUser(hUser, "SteamUser004"));
su->FreeLastCallback();
}
STEAMCLIENT_API int Steam3_GetSteamTicket( HSteamUser hUser, void *pBlob, int cbMaxBlob )
{
PRINT_DEBUG_ENTRY();
if (get_steam_client()->steamclient_version != 4)
return 0;
ISteamUser004_old *su = reinterpret_cast<ISteamUser004_old *>(get_steam_client()->GetISteamUser(hUser, "SteamUser004"));
return su->GetSteamTicket(pBlob, cbMaxBlob);
}
STEAMCLIENT_API void Steam3_SetLocalIPBinding( uint32 unIP, uint16 usLocalPort )
{
PRINT_DEBUG_ENTRY();
get_steam_client()->SetLocalIPBinding(unIP, usLocalPort);
}
// older sdk ----------------------------------------------------------

58
dll/dll/capicmcallback.h Normal file
View file

@ -0,0 +1,58 @@
#ifndef __INCLUDED_CAPICMCALLBACK_H__
#define __INCLUDED_CAPICMCALLBACK_H__
#include "base.h"
typedef void (*OnLogonSuccessFunc)();
typedef void (*OnLogonFailureFunc)(EResult);
typedef void (*OnLoggedOffFunc)();
typedef void (*OnBeginLogonRetryFunc)();
typedef void (*HandleVACChallengeFunc)(int, void *, int);
typedef void (*GSHandleClientApproveFunc)(CSteamID *);
typedef void (*GSHandleClientDenyFunc)(CSteamID *, EDenyReason);
typedef void (*GSHandleClientKickFunc)(CSteamID *, EDenyReason);
class CCAPICMCallBack : public ICMCallback
{
public:
CCAPICMCallBack(OnLogonSuccessFunc func1,
OnLogonFailureFunc func2,
OnLoggedOffFunc func3,
OnBeginLogonRetryFunc func4,
HandleVACChallengeFunc func5,
GSHandleClientApproveFunc func6,
GSHandleClientDenyFunc func7,
GSHandleClientKickFunc func8)
{
OnLogonSuccess_ptr = func1;
OnLogonFailure_ptr = func2;
OnLoggedOff_ptr = func3;
OnBeginLogonRetry_ptr = func4;
HandleVACChallenge_ptr = func5;
GSHandleClientApprove_ptr = func6;
GSHandleClientDeny_ptr = func7;
GSHandleClientKick_ptr = func8;
}
~CCAPICMCallBack() {}
void OnLogonSuccess() { OnLogonSuccess_ptr(); }
void OnLogonFailure(EResult result) { OnLogonFailure_ptr(result); }
void OnLoggedOff() { OnLoggedOff_ptr(); }
void OnBeginLogonRetry() { OnBeginLogonRetry_ptr(); }
void HandleVACChallenge(int unk1, void *unk2, int unk3) { HandleVACChallenge_ptr(unk1, unk2, unk3); }
void GSHandleClientApprove(CSteamID *steamID) { GSHandleClientApprove_ptr(steamID); }
void GSHandleClientDeny(CSteamID *steamID, EDenyReason reason) { GSHandleClientDeny_ptr(steamID, reason); }
void GSHandleClientKick(CSteamID *steamID, EDenyReason reason) { GSHandleClientKick_ptr(steamID, reason); }
private:
OnLogonSuccessFunc OnLogonSuccess_ptr{};
OnLogonFailureFunc OnLogonFailure_ptr{};
OnLoggedOffFunc OnLoggedOff_ptr{};
OnBeginLogonRetryFunc OnBeginLogonRetry_ptr{};
HandleVACChallengeFunc HandleVACChallenge_ptr{};
GSHandleClientApproveFunc GSHandleClientApprove_ptr{};
GSHandleClientDenyFunc GSHandleClientDeny_ptr{};
GSHandleClientKickFunc GSHandleClientKick_ptr{};
};
#endif // __INCLUDED_CAPICMCALLBACK_H__

2
dll/dll/common_includes.h
View file

@ -208,7 +208,7 @@ static inline void reset_LastError()
// Emulator defines
#define CLIENT_HSTEAMUSER 1
#define SERVER_HSTEAMUSER 1
#define SERVER_HSTEAMUSER 2
#define DEFAULT_NAME "gse orca"
#define DEFAULT_LANGUAGE "english"

2
dll/dll/dll.h
View file

@ -30,6 +30,8 @@
Steam_Client *get_steam_client();
bool steamclient_has_ipv6_functions();
bool steamclient_get_callback(HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg);
void steamclient_free_callback(HSteamPipe hSteamPipe);
HSteamUser flat_hsteamuser();
HSteamPipe flat_hsteampipe();

29
dll/dll/steam_client.h
View file

@ -69,6 +69,11 @@ enum Steam_Pipe {
};
class Steam_Client :
public ISteamClient001,
public ISteamClient002,
public ISteamClient003,
public ISteamClient004,
public ISteamClient005,
public ISteamClient006,
public ISteamClient007,
public ISteamClient008,
@ -147,6 +152,7 @@ public:
Steam_Billing *steam_billing{};
Steam_GameServer *steam_gameserver{};
Steam_User *steam_gameserver_user{};
Steam_Utils *steam_gameserver_utils{};
Steam_GameServerStats *steam_gameserverstats{};
Steam_Networking *steam_gameserver_networking{};
@ -168,6 +174,7 @@ public:
bool steamclient_server_inited = false;
bool gameserver_has_ipv6_functions{};
int steamclient_version{};
unsigned steam_pipe_counter = 1;
std::map<HSteamPipe, enum Steam_Pipe> steam_pipes{};
@ -362,11 +369,33 @@ public:
// returns the name of a universe
const char *GetUniverseName( EUniverse eUniverse );
void *GetISteamBilling_old( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion );
HSteamUser CreateGlobalInstance();
HSteamUser ConnectToGlobalInstance();
HSteamUser CreateLocalInstance();
void ReleaseInstance( HSteamUser hSteamUser );
ISteamUser *GetISteamUser( HSteamUser hSteamUser, const char *pchVersion );
ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, const char *pchVersion );
bool BMainLoop( uint64 time );
bool BMainLoop( uint64 time, bool unk );
EUniverse GetConnectedUniverse();
bool BGetCallback( HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg, int *unk );
void FreeLastCallback( HSteamPipe hSteamPipe );
void SetEUniverse( EUniverse universe );
void Test_SetSpew( const char *unk1, int unk2 ) {}
void Test_SetSpewFunc( void *unk ) {}
void Test_OverrideIPs( uint32 unIPPublic, uint32 unIPPrivate ) {}
void Test_SetServerLoadState( bool unk1, bool unk2 ) {}
void Test_SetStressMode( bool unk ) {}
int Test_GetStatsVConn() { return 0; }
void Test_RemoveAllClients() {}
// older sdk ----------------------------------------------------------
void report_missing_impl(std::string_view itf, std::string_view caller);
[[noreturn]] void report_missing_impl_and_exit(std::string_view itf, std::string_view caller);
HSteamPipe get_pipe_for_user(HSteamUser hUser);
};
#endif // __INCLUDED_STEAM_CLIENT_H__

9
dll/dll/steam_gameserver.h
View file

@ -39,6 +39,7 @@ struct Gameserver_Player_Info_t {
};
class Steam_GameServer :
public ISteamGameServer001,
public ISteamGameServer002,
public ISteamGameServer003,
public ISteamGameServer004,
@ -73,15 +74,14 @@ public ISteamGameServer
std::vector<struct Gameserver_Outgoing_Packet> outgoing_packets{};
void set_version(const char *pchVersionString);
void add_player(CSteamID steamID);
void remove_player(CSteamID steamID);
public:
Steam_GameServer(class Settings *settings, class Networking *network, class SteamCallBacks *callbacks);
~Steam_GameServer();
std::vector<std::pair<CSteamID, Gameserver_Player_Info_t>>* get_players();
void add_player(CSteamID steamID);
void remove_player(CSteamID steamID);
//
// Basic server data. These properties, if set, must be set before before calling LogOn. They
@ -398,6 +398,9 @@ public:
bool GSSetServerType( int32 nGameAppId, uint32 unServerFlags, uint32 unGameIP, uint16 unGamePort, uint16 unSpectatorPort, uint16 usQueryPort, const char *pchGameDir, const char *pchVersion, bool bLANMode );
bool GSUpdateStatus( int cPlayers, int cPlayersMax, int cBotPlayers, const char *pchServerName, const char *pSpectatorServerName, const char *pchMapName );
bool GSGetUserAchievementStatus( CSteamID steamID, const char *pchAchievementName );
bool GSSendUserConnect( CSteamID steamID, uint32 unIPPublic, uint32 unk );
bool GSSendUserDisconnect( CSteamID steamID );
// older sdk -----------------------------------------------
};

57
dll/dll/steam_user.h
View file

@ -23,6 +23,10 @@
#include "voicechat.h"
class Steam_User :
public ISteamUser001,
public ISteamUser002_old,
public ISteamUser002,
public ISteamUser004_old,
public ISteamUser004,
public ISteamUser005,
public ISteamUser006,
@ -56,6 +60,14 @@ public ISteamUser
std::map<std::string, std::string> registry{};
std::string registry_nullptr{};
ICMCallback001 *callbacks_old1{};
ICMCallback *callbacks_old2{};
bool call_logged_on{};
std::chrono::high_resolution_clock::time_point logon_time{};
bool call_logged_off{};
std::chrono::high_resolution_clock::time_point logoff_time{};
std::vector<std::pair<CSteamID, std::chrono::high_resolution_clock::time_point>> player_auths{};
public:
Steam_User(Settings *settings, Local_Storage *local_storage, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks);
~Steam_User();
@ -313,6 +325,51 @@ public:
// playtime limits.
bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState );
// called by steam_client::runcallbacks
void RunCallbacks();
// older sdk -----------------------------------------------
void Init( ICMCallback001 *cmcallback, ISteam2Auth *steam2auth );
void Init( ICMCallback *cmcallback, ISteam2Auth *steam2auth );
int ProcessCall( int unk );
virtual void LogOn( CSteamID *steamID );
virtual int CreateAccount( const char *unk1, void *unk2, void *unk3, const char *unk4, int unk5, void *unk6 );
virtual bool GSSendLogonRequest( CSteamID *steamID );
virtual bool GSSendDisconnect( CSteamID *steamID );
virtual bool GSSendStatusResponse( CSteamID *steamID, int nSecondsConnected, int nSecondsSinceLast );
virtual bool GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax );
virtual bool GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax, int cBotPlayers, int unGamePort, const char *pchServerName, const char *pchGameDir, const char *pchMapName, const char *pchVersion );
bool BGetCallback( int *piCallback, uint8 **ppubParam, int *unk );
void FreeLastCallback();
int GetSteamTicket( void *pBlob, int cbMaxBlob );
const char *GetPlayerName();
void SetPlayerName( const char *pchPersonaName );
EPersonaState GetFriendStatus();
void SetFriendStatus( EPersonaState ePersonaState );
bool AddFriend( CSteamID steamIDFriend );
bool RemoveFriend( CSteamID steamIDFriend );
bool HasFriend( CSteamID steamIDFriend );
EFriendRelationship GetFriendRelationship( CSteamID steamIDFriend );
EPersonaState GetFriendStatus( CSteamID steamIDFriend );
bool GetFriendGamePlayed( CSteamID steamIDFriend, int32 *pnGameID, uint32 *punGameIP, uint16 *pusGamePort );
const char *GetPlayerName( CSteamID steamIDFriend );
int32 AddFriendByName( const char *pchEmailOrAccountName );
virtual void Test_SuspendActivity() {}
virtual void Test_ResumeActivity() {}
virtual void Test_SendVACResponse( int unk1, void *unk2, int unk3 ) {}
virtual void Test_SetFakePrivateIP( uint32 ip ) {}
virtual void Test_SendBigMessage() {}
virtual bool Test_BBigMessageResponseReceived() { return true; }
virtual void Test_SetPktLossPct( int unk1 ) {}
virtual void Test_SetForceTCP( bool unk1 ) {}
virtual void Test_SetMaxUDPConnectionAttempts( int unk1 ) {}
virtual void Test_Heartbeat() {}
virtual void Test_FakeDisconnect() {}
virtual EUniverse Test_GetEUniverse() { return k_EUniversePublic; }
// older sdk -----------------------------------------------
};
#endif // __INCLUDED_STEAM_USER_H__

2
dll/settings_parser.cpp
View file

@ -1814,7 +1814,7 @@ uint32 create_localstorage_settings(Settings **settings_client_out, Settings **s
PRINT_DEBUG("setting emu to offline mode");
}
Settings *settings_client = new Settings(user_id, CGameID(appid), name, language, steam_offline_mode);
Settings *settings_server = new Settings(generate_steam_id_server(), CGameID(appid), name, language, steam_offline_mode);
Settings *settings_server = new Settings(generate_steam_id_server(), CGameID(appid), name, language, true); // server starts logged out
settings_client->alt_steamid = alt_steamid;
settings_client->alt_steamid_count = alt_steamid_count;

112
dll/steam_client.cpp
View file

@ -17,6 +17,7 @@
#include "dll/steam_client.h"
#include "dll/settings_parser.h"
#include "dll/dll.h"
void Steam_Client::background_thread_proc()
@ -133,6 +134,7 @@ Steam_Client::Steam_Client()
callbacks_server = new SteamCallBacks(callback_results_server);
steam_gameserver = new Steam_GameServer(settings_server, network, callbacks_server);
steam_gameserver_user = new Steam_User(settings_server, local_storage, network, callback_results_server, callbacks_server);
steam_gameserver_utils = new Steam_Utils(settings_server, callback_results_server, callbacks_server, steam_overlay);
steam_gameserverstats = new Steam_GameServerStats(settings_server, network, callback_results_server, callbacks_server, run_every_runcb);
steam_gameserver_networking = new Steam_Networking(settings_server, network, callbacks_server, run_every_runcb);
@ -151,6 +153,7 @@ Steam_Client::Steam_Client()
steam_app_ticket = new Steam_AppTicket(settings_client);
gameserver_has_ipv6_functions = false;
steamclient_version = 6; // default for C exports
last_cb_run = 0;
PRINT_DEBUG("end *********");
@ -940,6 +943,9 @@ void Steam_Client::RunCallbacks(bool runClientCB, bool runGameserverCB)
// PRINT_DEBUG("steam_gameserver *********");
steam_gameserver->RunCallbacks();
// PRINT_DEBUG("steam_user *********");
steam_gameserver_user->RunCallbacks();
if (runClientCB) {
// PRINT_DEBUG("callback_results_client *********");
callback_results_client->runCallResults();
@ -1014,4 +1020,110 @@ const char *Steam_Client::GetUniverseName( EUniverse eUniverse )
return "Unknown";
}
HSteamUser Steam_Client::CreateGlobalInstance()
{
PRINT_DEBUG_ENTRY();
HSteamPipe pipe = 0;
return CreateGlobalUser(&pipe);
}
HSteamUser Steam_Client::ConnectToGlobalInstance()
{
PRINT_DEBUG_ENTRY();
HSteamPipe pipe = get_pipe_for_user(CLIENT_HSTEAMUSER);
if (!pipe) {
pipe = CreateSteamPipe();
}
return ConnectToGlobalUser(pipe);
}
HSteamUser Steam_Client::CreateLocalInstance()
{
PRINT_DEBUG_ENTRY();
HSteamPipe pipe = 0;
return CreateLocalUser(&pipe);
}
void Steam_Client::ReleaseInstance( HSteamUser hSteamUser )
{
PRINT_DEBUG_ENTRY();
HSteamPipe pipe = get_pipe_for_user(hSteamUser);
if (pipe) {
ReleaseUser(pipe, hSteamUser);
BReleaseSteamPipe(pipe);
}
}
ISteamUser *Steam_Client::GetISteamUser( HSteamUser hSteamUser, const char *pchVersion )
{
PRINT_DEBUG_ENTRY();
HSteamPipe pipe = get_pipe_for_user(hSteamUser);
return GetISteamUser(hSteamUser, pipe, pchVersion);
}
ISteamGameServer *Steam_Client::GetISteamGameServer( HSteamUser hSteamUser, const char *pchVersion )
{
PRINT_DEBUG_ENTRY();
HSteamPipe pipe = get_pipe_for_user(hSteamUser);
return GetISteamGameServer(hSteamUser, pipe, pchVersion);
}
bool Steam_Client::BMainLoop( uint64 time, bool unk )
{
PRINT_DEBUG_ENTRY();
RunCallbacks(true, true);
return true;
}
bool Steam_Client::BMainLoop( uint64 time )
{
PRINT_DEBUG_ENTRY();
RunCallbacks(true, true);
return true;
}
EUniverse Steam_Client::GetConnectedUniverse()
{
PRINT_DEBUG_ENTRY();
return k_EUniversePublic;
}
void Steam_Client::SetEUniverse( EUniverse universe )
{
PRINT_DEBUG_TODO();
}
bool Steam_Client::BGetCallback( HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg, int *unk )
{
PRINT_DEBUG_ENTRY();
return steamclient_get_callback(hSteamPipe, pCallbackMsg);
}
void Steam_Client::FreeLastCallback( HSteamPipe hSteamPipe )
{
PRINT_DEBUG_ENTRY();
steamclient_free_callback(hSteamPipe);
}
HSteamPipe Steam_Client::get_pipe_for_user(HSteamUser hUser)
{
if (hUser == CLIENT_HSTEAMUSER) {
for (const auto &[pipe_handle, pipe_type] : steam_pipes) {
if (pipe_type == Steam_Pipe::CLIENT) {
return pipe_handle;
}
}
} else if (hUser == SERVER_HSTEAMUSER) {
for (const auto &[pipe_handle, pipe_type] : steam_pipes) {
if (pipe_type == Steam_Pipe::SERVER) {
return pipe_handle;
}
}
}
return 0;
}
// older sdk ----------------------------------------------------------

66
dll/steam_client_interface_getter.cpp
View file

@ -109,46 +109,68 @@ ISteamUser *Steam_Client::GetISteamUser( HSteamUser hSteamUser, HSteamPipe hStea
}
if (strcmp(pchVersion, "SteamUser004") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser004 *>(steam_user)); // sdk 0.99u
Steam_User *steam_user_tmp{};
if (steam_pipes[hSteamPipe] == Steam_Pipe::SERVER) {
steam_user_tmp = steam_gameserver_user;
} else {
steam_user_tmp = steam_user;
}
if (strcmp(pchVersion, "SteamUser001") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser001 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser002") == 0) {
// Ugh...
if (steamclient_version < 2) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser002_old *>(steam_user_tmp));
} else {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser002 *>(steam_user_tmp));
}
} else if (strcmp(pchVersion, "SteamUser004") == 0) {
// Double ugh...
if (steamclient_version < 5) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser004_old *>(steam_user_tmp));
} else {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser004 *>(steam_user_tmp)); // sdk 0.99u
}
} else if (strcmp(pchVersion, "SteamUser005") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser005 *>(steam_user)); // sdk 0.99v
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser005 *>(steam_user_tmp)); // sdk 0.99v
} else if (strcmp(pchVersion, "SteamUser006") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser006 *>(steam_user)); // sdk 0.99w
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser006 *>(steam_user_tmp)); // sdk 0.99w
} else if (strcmp(pchVersion, "SteamUser007") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser007 *>(steam_user)); // sdk 0.99x
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser007 *>(steam_user_tmp)); // sdk 0.99x
} else if (strcmp(pchVersion, "SteamUser008") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser008 *>(steam_user)); // sdk 0.99y
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser008 *>(steam_user_tmp)); // sdk 0.99y
} else if (strcmp(pchVersion, "SteamUser009") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser009 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser009 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser010") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser010 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser010 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser011") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser011 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser011 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser012") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser012 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser012 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser013") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser013 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser013 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser014") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser014 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser014 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser015") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser015 *>(steam_user)); // SteamUser015 Not found in public Archive, must be between 1.12-1.13
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser015 *>(steam_user_tmp)); // SteamUser015 Not found in public Archive, must be between 1.12-1.13
} else if (strcmp(pchVersion, "SteamUser016") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser016 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser016 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser017") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser017 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser017 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser018") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser018 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser018 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser019") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser019 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser019 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser020") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser020 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser020 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser021") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser021 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser021 *>(steam_user_tmp));
} else if (strcmp(pchVersion, "SteamUser022") == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser022 *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser022 *>(steam_user_tmp));
} else if (strcmp(pchVersion, STEAMUSER_INTERFACE_VERSION) == 0) {
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser *>(steam_user));
return reinterpret_cast<ISteamUser *>(static_cast<ISteamUser *>(steam_user_tmp));
}
report_missing_impl_and_exit(pchVersion, EMU_FUNC_NAME);
@ -162,7 +184,7 @@ ISteamGameServer *Steam_Client::GetISteamGameServer( HSteamUser hSteamUser, HSte
if (strcmp(pchVersion, "SteamGameServer001") == 0) {
return nullptr;
return reinterpret_cast<ISteamGameServer *>(static_cast<ISteamGameServer001 *>(steam_gameserver));
} else if (strcmp(pchVersion, "SteamGameServer002") == 0) {
return reinterpret_cast<ISteamGameServer *>(static_cast<ISteamGameServer002 *>(steam_gameserver)); // not found in public archives, from proton repo src
} else if (strcmp(pchVersion, "SteamGameServer003") == 0) {

50
dll/steam_gameserver.cpp
View file

@ -184,7 +184,9 @@ void Steam_GameServer::LogOn( const char *pszToken )
PRINT_DEBUG("%s", pszToken);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
call_servers_connected = true;
call_servers_disconnected = false;
logged_in = true;
settings->set_offline(false);
}
void Steam_GameServer::LogOn(
@ -205,7 +207,9 @@ void Steam_GameServer::LogOnAnonymous()
PRINT_DEBUG_ENTRY();
std::lock_guard<std::recursive_mutex> lock(global_mutex);
call_servers_connected = true;
call_servers_disconnected = false;
logged_in = true;
settings->set_offline(false);
}
void Steam_GameServer::LogOn()
@ -220,11 +224,13 @@ void Steam_GameServer::LogOff()
PRINT_DEBUG_ENTRY();
std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (logged_in) {
call_servers_connected = false;
call_servers_disconnected = true;
}
policy_response_called = false;
logged_in = false;
settings->set_offline(true);
}
@ -846,7 +852,7 @@ void Steam_GameServer::RunCallbacks()
policy_response_called = true;
}
if (logged_in && check_timedout(last_sent_server_info, SEND_SERVER_RATE)) {
if (logged_in && server_data.port() != 0 && check_timedout(last_sent_server_info, SEND_SERVER_RATE)) {
PRINT_DEBUG("Sending Gameserver");
Common_Message msg{};
msg.set_source_id(settings->get_local_steam_id().ConvertToUint64());
@ -855,7 +861,7 @@ void Steam_GameServer::RunCallbacks()
if (server_data.mod_dir().empty())
server_data.set_mod_dir(server_data.game_dir());
msg.set_allocated_gameserver(new Gameserver(server_data));
msg.mutable_gameserver()->set_num_players(auth_manager->countInboundAuth());
//msg.mutable_gameserver()->set_num_players(auth_manager->countInboundAuth());
network->sendToAllIndividuals(&msg, true);
last_sent_server_info = std::chrono::high_resolution_clock::now();
}
@ -957,11 +963,22 @@ bool Steam_GameServer::Obsolete_GSSetStatus( int32 nAppIdServed, uint32 unServer
PRINT_DEBUG_ENTRY();
std::lock_guard<std::recursive_mutex> lock(global_mutex);
server_data.set_appid(nAppIdServed);
server_data.set_num_players(cPlayers);
server_data.set_max_player_count(cPlayersMax);
server_data.set_bot_player_count(cBotPlayers);
server_data.set_port(unGamePort);
server_data.set_query_port(0xFFFF);
server_data.set_server_name(pchServerName);
server_data.set_spectator_server_name("");
server_data.set_game_dir(pchGameDir ? pchGameDir : "");
server_data.set_map_name(pchMapName);
set_version(pchVersion);
server_data.set_game_dir(pchGameDir);
server_data.set_offline(false);
if (!settings->get_local_game_id().AppID()) settings->set_game_id(CGameID(nAppIdServed));
flags = unServerFlags;
UpdateServerStatus(cPlayers, cPlayersMax, cBotPlayers, pchServerName, "", pchMapName);
return true;
}
@ -979,7 +996,7 @@ bool Steam_GameServer::GSSetServerType( int32 nGameAppId, uint32 unServerFlags,
PRINT_DEBUG_ENTRY();
std::lock_guard<std::recursive_mutex> lock(global_mutex);
bool ret = BSetServerType(unServerFlags, unGameIP, unGamePort, 0, 0, pchGameDir, pchVersion, false);
bool ret = BSetServerType(unServerFlags, unGameIP, unGamePort, 0xFFFF, 0xFFFF, pchGameDir, pchVersion, false);
server_data.set_appid(nGameAppId);
return ret;
}
@ -1081,4 +1098,27 @@ bool Steam_GameServer::GSGetUserAchievementStatus( CSteamID steamID, const char
return BGetUserAchievementStatus(steamID, pchAchievementName);
}
bool Steam_GameServer::GSSendUserConnect( CSteamID steamID, uint32 unIPPublic, uint32 unk )
{
PRINT_DEBUG("%llu %u %u", steamID.ConvertToUint64(), unIPPublic, unk);
std::lock_guard<std::recursive_mutex> lock(global_mutex);
// Note that SteamID passed into this comes from Steam.dll so it won't match the client's Goldberg SteamID.
// POINTLESS TO USE AUTH MANAGER.
GSClientApprove_t data{};
data.m_SteamID = data.m_OwnerSteamID = steamID;
callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
add_player(steamID);
return true;
}
bool Steam_GameServer::GSSendUserDisconnect( CSteamID steamID )
{
PRINT_DEBUG("%llu", steamID.ConvertToUint64());
std::lock_guard<std::recursive_mutex> lock(global_mutex);
remove_player(steamID);
return true;
}
// older sdk -----------------------------------------------

251
dll/steam_user.cpp
View file

@ -19,6 +19,7 @@
#include "dll/auth.h"
#include "dll/appticket.h"
#include "dll/base64.h"
#include "dll/dll.h"
Steam_User::Steam_User(Settings *settings, Local_Storage *local_storage, class Networking *network, class SteamCallResults *callback_results, class SteamCallBacks *callbacks)
{
@ -42,19 +43,34 @@ Steam_User::~Steam_User()
HSteamUser Steam_User::GetHSteamUser()
{
PRINT_DEBUG_ENTRY();
return CLIENT_HSTEAMUSER;
return (settings == get_steam_client()->settings_server) ? SERVER_HSTEAMUSER : CLIENT_HSTEAMUSER;
}
void Steam_User::LogOn( CSteamID steamID )
{
PRINT_DEBUG_ENTRY();
settings->set_offline(false);
logon_time = std::chrono::high_resolution_clock::now();
call_logged_on = true;
call_logged_off = false;
if (settings == get_steam_client()->settings_server) {
get_steam_client()->steam_gameserver->LogOnAnonymous();
}
}
void Steam_User::LogOff()
{
PRINT_DEBUG_ENTRY();
settings->set_offline(true);
logoff_time = std::chrono::high_resolution_clock::now();
call_logged_on = false;
call_logged_off = true;
player_auths.clear();
if (settings == get_steam_client()->settings_server) {
get_steam_client()->steam_gameserver->LogOff();
}
}
// returns true if the Steam client current has a live connection to the Steam servers.
@ -863,3 +879,236 @@ bool Steam_User::BSetDurationControlOnlineState( EDurationControlOnlineState eNe
PRINT_DEBUG_ENTRY();
return false;
}
// older sdk -----------------------------------------------
void Steam_User::Init( ICMCallback001 *cmcallback, ISteam2Auth *steam2auth )
{
PRINT_DEBUG_ENTRY();
callbacks_old1 = cmcallback;
}
void Steam_User::Init( ICMCallback *cmcallback, ISteam2Auth *steam2auth )
{
PRINT_DEBUG_ENTRY();
callbacks_old2 = cmcallback;
}
int Steam_User::ProcessCall( int unk )
{
PRINT_DEBUG_TODO();
return 0;
}
void Steam_User::LogOn( CSteamID *steamID )
{
PRINT_DEBUG_ENTRY();
LogOn(*steamID);
}
int Steam_User::CreateAccount( const char *unk1, void *unk2, void *unk3, const char *unk4, int unk5, void *unk6 )
{
PRINT_DEBUG_TODO();
return 0;
}
bool Steam_User::GSSendLogonRequest( CSteamID *steamID )
{
PRINT_DEBUG("%llu", (*steamID).ConvertToUint64());
// Note that SteamID passed into this comes from Steam.dll so it won't match the client's Goldberg SteamID.
std::pair<CSteamID, std::chrono::high_resolution_clock::time_point> entry(*steamID, std::chrono::high_resolution_clock::now());
player_auths.push_back(entry);
get_steam_client()->steam_gameserver->add_player(*steamID);
return true;
}
bool Steam_User::GSSendDisconnect( CSteamID *steamID )
{
PRINT_DEBUG("%llu", (*steamID).ConvertToUint64());
get_steam_client()->steam_gameserver->remove_player(*steamID);
return true;
}
bool Steam_User::GSSendStatusResponse( CSteamID *steamID, int nSecondsConnected, int nSecondsSinceLast )
{
PRINT_DEBUG_TODO();
return false;
}
bool Steam_User::GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax )
{
PRINT_DEBUG_TODO();
return true;
}
bool Steam_User::GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax, int cBotPlayers, int unGamePort, const char *pchServerName, const char *pchGameDir, const char *pchMapName, const char *pchVersion )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_gameserver->Obsolete_GSSetStatus(nAppIdServed, unServerFlags, cPlayers, cPlayersMax, cBotPlayers, unGamePort, pchServerName, pchGameDir, pchMapName, pchVersion);
}
bool Steam_User::BGetCallback( int *piCallback, uint8 **ppubParam, int *unk )
{
PRINT_DEBUG_ENTRY();
HSteamUser user = (settings == get_steam_client()->settings_server) ? SERVER_HSTEAMUSER : CLIENT_HSTEAMUSER;
HSteamPipe pipe = get_steam_client()->get_pipe_for_user(user);
if (!pipe)
return false;
CallbackMsg_t msg;
if (!steamclient_get_callback(pipe, &msg))
return false;
*piCallback = msg.m_iCallback;
*ppubParam = msg.m_pubParam;
return true;
}
void Steam_User::FreeLastCallback()
{
PRINT_DEBUG_ENTRY();
HSteamUser user = (settings == get_steam_client()->settings_server) ? SERVER_HSTEAMUSER : CLIENT_HSTEAMUSER;
HSteamPipe pipe = get_steam_client()->get_pipe_for_user(user);
if (!pipe)
return;
steamclient_free_callback(pipe);
}
int Steam_User::GetSteamTicket( void *pBlob, int cbMaxBlob )
{
PRINT_DEBUG_ENTRY();
std::lock_guard<std::recursive_mutex> lock(global_mutex);
if (cbMaxBlob < STEAM_TICKET_MIN_SIZE) return 0;
if (!pBlob) return 0;
uint32 out_size = STEAM_AUTH_TICKET_SIZE;
auth_manager->getTicketData(pBlob, cbMaxBlob, &out_size);
if (out_size > STEAM_AUTH_TICKET_SIZE)
return 0;
return out_size;
}
const char *Steam_User::GetPlayerName()
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->GetPersonaName();
}
void Steam_User::SetPlayerName( const char *pchPersonaName )
{
PRINT_DEBUG_ENTRY();
get_steam_client()->steam_friends->SetPersonaName_old(pchPersonaName);
}
EPersonaState Steam_User::GetFriendStatus()
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->GetPersonaState();
}
void Steam_User::SetFriendStatus( EPersonaState ePersonaState )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->SetPersonaState(ePersonaState);
}
bool Steam_User::AddFriend( CSteamID steamIDFriend )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->AddFriend(steamIDFriend);
}
bool Steam_User::RemoveFriend( CSteamID steamIDFriend )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->RemoveFriend(steamIDFriend);
}
bool Steam_User::HasFriend( CSteamID steamIDFriend )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->HasFriend(steamIDFriend);
}
EFriendRelationship Steam_User::GetFriendRelationship( CSteamID steamIDFriend )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->GetFriendRelationship(steamIDFriend);
}
EPersonaState Steam_User::GetFriendStatus( CSteamID steamIDFriend )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->GetFriendPersonaState(steamIDFriend);
}
bool Steam_User::GetFriendGamePlayed( CSteamID steamIDFriend, int32 *pnGameID, uint32 *punGameIP, uint16 *pusGamePort )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->Deprecated_GetFriendGamePlayed(steamIDFriend, pnGameID, punGameIP, pusGamePort);
}
const char *Steam_User::GetPlayerName( CSteamID steamIDFriend )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->GetFriendPersonaName(steamIDFriend);
}
int32 Steam_User::AddFriendByName( const char *pchEmailOrAccountName )
{
PRINT_DEBUG_ENTRY();
return get_steam_client()->steam_friends->AddFriendByName(pchEmailOrAccountName);
}
// older sdk -----------------------------------------------
void Steam_User::RunCallbacks()
{
if (callbacks_old1) {
if (call_logged_on && check_timedout(logon_time, 0.1)) {
PRINT_DEBUG("ICMCallback -> OnLogonSuccess");
callbacks_old1->OnLogonSuccess();
call_logged_on = false;
}
if (call_logged_off && check_timedout(logoff_time, 0.1)) {
PRINT_DEBUG("ICMCallback -> OnLoggedOff");
callbacks_old1->OnLoggedOff();
call_logged_off = false;
}
for (auto it = player_auths.begin(); it != player_auths.end();) {
if (check_timedout(it->second, 0.1)) {
PRINT_DEBUG("ICMCallback -> GSHandleClientApprove %llu", it->first.ConvertToUint64());
callbacks_old1->GSHandleClientApprove(&(it->first));
it = player_auths.erase(it);
} else {
it++;
}
}
} else if (callbacks_old2) {
if (call_logged_on && check_timedout(logon_time, 0.1)) {
PRINT_DEBUG("ICMCallback -> OnLogonSuccess");
callbacks_old2->OnLogonSuccess();
call_logged_on = false;
}
if (call_logged_off && check_timedout(logoff_time, 0.1)) {
PRINT_DEBUG("ICMCallback -> OnLoggedOff");
callbacks_old2->OnLoggedOff();
call_logged_off = false;
}
for (auto it = player_auths.begin(); it != player_auths.end();) {
if (check_timedout(it->second, 0.1)) {
PRINT_DEBUG("ICMCallback -> GSHandleClientApprove %llu", it->first.ConvertToUint64());
callbacks_old2->GSHandleClientApprove(&(it->first));
it = player_auths.erase(it);
} else {
it++;
}
}
}
}

30
sdk/steam/isteamclient001.h Normal file
View file

@ -0,0 +1,30 @@
#ifndef ISTEAMCLIENT001_H
#define ISTEAMCLIENT001_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
#include "isteammasterserverupdater.h"
class ISteamClient001
{
public:
virtual HSteamUser CreateGlobalInstance() = 0;
virtual HSteamUser ConnectToGlobalInstance() = 0;
virtual HSteamUser CreateLocalInstance() = 0;
virtual void ReleaseInstance( HSteamUser hSteamUser ) = 0;
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, const char *pchVersion ) = 0;
virtual void *GetIVAC( HSteamUser hSteamUser ) = 0;
virtual bool BMainLoop( uint64 time, bool unk ) = 0;
virtual void Test_SetSpew( const char *unk1, int unk2 ) = 0;
virtual void Test_SetSpewFunc( void *unk ) = 0;
virtual void Test_OverrideIPs( uint32 unIPPublic, uint32 unIPPrivate ) = 0;
virtual void Test_SetServerLoadState( bool unk1, bool unk2 ) = 0;
virtual void Test_SetStressMode( bool unk ) = 0;
virtual int Test_GetStatsVConn() = 0;
};
#endif // ISTEAMCLIENT001_H

31
sdk/steam/isteamclient002.h Normal file
View file

@ -0,0 +1,31 @@
#ifndef ISTEAMCLIENT002_H
#define ISTEAMCLIENT002_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
#include "isteammasterserverupdater.h"
class ISteamClient002
{
public:
virtual HSteamUser CreateGlobalInstance() = 0;
virtual HSteamUser ConnectToGlobalInstance() = 0;
virtual HSteamUser CreateLocalInstance() = 0;
virtual void ReleaseInstance( HSteamUser hSteamUser ) = 0;
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, const char *pchVersion ) = 0;
virtual void *GetIVAC( HSteamUser hSteamUser ) = 0;
virtual bool BMainLoop( uint64 time, bool unk ) = 0;
virtual void Test_SetSpew( const char *unk1, int unk2 ) = 0;
virtual void Test_SetSpewFunc( void *unk ) = 0;
virtual void Test_OverrideIPs( uint32 unIPPublic, uint32 unIPPrivate ) = 0;
virtual void Test_SetServerLoadState( bool unk1, bool unk2 ) = 0;
virtual void Test_SetStressMode( bool unk ) = 0;
virtual int Test_GetStatsVConn() = 0;
virtual void Test_RemoveAllClients() = 0;
};
#endif // ISTEAMCLIENT002_H

31
sdk/steam/isteamclient003.h Normal file
View file

@ -0,0 +1,31 @@
#ifndef ISTEAMCLIENT003_H
#define ISTEAMCLIENT003_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
#include "isteammasterserverupdater.h"
class ISteamClient003
{
public:
virtual HSteamUser CreateGlobalInstance() = 0;
virtual HSteamUser ConnectToGlobalInstance() = 0;
virtual HSteamUser CreateLocalInstance() = 0;
virtual void ReleaseInstance( HSteamUser hSteamUser ) = 0;
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, const char *pchVersion ) = 0;
virtual void *GetIVAC( HSteamUser hSteamUser ) = 0;
virtual bool BMainLoop( uint64 time ) = 0;
virtual void Test_SetSpew( const char *unk1, int unk2 ) = 0;
virtual void Test_SetSpewFunc( void *unk ) = 0;
virtual void Test_OverrideIPs( uint32 unIPPublic, uint32 unIPPrivate ) = 0;
virtual void Test_SetServerLoadState( bool unk1, bool unk2 ) = 0;
virtual void Test_SetStressMode( bool unk ) = 0;
virtual int Test_GetStatsVConn() = 0;
virtual void Test_RemoveAllClients() = 0;
};
#endif // ISTEAMCLIENT003_H

25
sdk/steam/isteamclient004.h Normal file
View file

@ -0,0 +1,25 @@
#ifndef ISTEAMCLIENT004_H
#define ISTEAMCLIENT004_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
#include "isteammasterserverupdater.h"
class ISteamClient004
{
public:
virtual HSteamUser CreateGlobalInstance() = 0;
virtual HSteamUser ConnectToGlobalInstance() = 0;
virtual HSteamUser CreateLocalInstance() = 0;
virtual void ReleaseInstance( HSteamUser hSteamUser ) = 0;
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, const char *pchVersion ) = 0;
virtual void *GetIVAC( HSteamUser hSteamUser ) = 0;
virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, const char *pchVersion ) = 0;
virtual void SetLocalIPBinding( uint32 unIP, uint16 usPort ) = 0;
};
#endif // ISTEAMCLIENT004_H

33
sdk/steam/isteamclient005.h Normal file
View file

@ -0,0 +1,33 @@
#ifndef ISTEAMCLIENT005_H
#define ISTEAMCLIENT005_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
#include "isteammasterserverupdater.h"
class ISteamClient005
{
public:
virtual HSteamPipe CreateSteamPipe() = 0;
virtual bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) = 0;
virtual HSteamUser CreateGlobalUser( HSteamPipe *phSteamPipe ) = 0;
virtual HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) = 0;
virtual HSteamUser CreateLocalUser( HSteamPipe *phSteamPipe ) = 0;
virtual void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) = 0;
virtual ISteamUser *GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
virtual void *GetIVAC( HSteamUser hSteamUser ) = 0;
virtual ISteamGameServer *GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
virtual void SetLocalIPBinding( uint32 unIP, uint16 usPort ) = 0;
virtual EUniverse GetConnectedUniverse() = 0;
virtual const char *GetUniverseName( EUniverse eUniverse ) = 0;
virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
virtual bool BGetCallback( HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg, int *unk ) = 0;
virtual void FreeLastCallback( HSteamPipe hSteamPipe ) = 0;
virtual void SetEUniverse( EUniverse universe ) = 0;
};
#endif // ISTEAMCLIENT005_H

19
sdk/steam/isteamgameserver001.h Normal file
View file

@ -0,0 +1,19 @@
#ifndef ISTEAMGAMESERVER001_H
#define ISTEAMGAMESERVER001_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
class ISteamGameServer001
{
public:
virtual bool GSSendUserConnect( CSteamID steamID, uint32 unIPPublic, uint32 unk ) = 0;
virtual bool GSSendUserDisconnect( CSteamID steamID ) = 0;
virtual bool GSSendUserStatusResponse( CSteamID steamID, int nSecondsConnected, int nSecondsSinceLast ) = 0;
virtual bool Obsolete_GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax, int cBotPlayers, int unGamePort, const char *pchServerName, const char *pchGameDir, const char *pchMapName, const char *pchVersion ) = 0;
};
#endif // ISTEAMGAMESERVER001_H

64
sdk/steam/isteamuser001.h Normal file
View file

@ -0,0 +1,64 @@
#ifndef ISTEAMUSER001_H
#define ISTEAMUSER001_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
class ICMCallback001
{
public:
virtual ~ICMCallback001() {}
virtual void OnLogonSuccess() = 0;
virtual void OnLogonFailure( EResult result ) = 0;
virtual void OnLoggedOff() = 0;
virtual void HandleVACChallenge( int unk1, void *unk2, int unk3 ) = 0;
virtual void GSHandleClientApprove( CSteamID *steamID ) = 0;
virtual void GSHandleClientDeny( CSteamID *steamID, EDenyReason reason ) = 0;
virtual void GSHandleClientKick( CSteamID *steamID, EDenyReason reason ) = 0;
};
class ISteam2Auth
{
public:
virtual int GetValue( const char *var, char *buf, int bufsize ) = 0;
virtual int GetServerReadableTicket( uint32 unk1, uint32 unk2, void *unk3, uint32 unk4, uint32 *unk5 ) = 0;
};
class ISteamUser001
{
public:
virtual void Init( ICMCallback001 *cmcallback, ISteam2Auth *steam2auth ) = 0;
virtual int ProcessCall( int unk ) = 0;
virtual void LogOn( CSteamID *steamID ) = 0;
virtual void LogOff() = 0;
virtual bool BLoggedOn() = 0;
virtual bool BConnected() = 0;
virtual int CreateAccount( const char *unk1, void *unk2, void *unk3, const char *unk4, int unk5, void *unk6 ) = 0;
virtual bool IsVACBanned( int nGameID ) = 0;
virtual bool RequireShowVACBannedMessage( int nGameID ) = 0;
virtual void AcknowledgeVACBanning( int nGameID ) = 0;
virtual bool GSSendLogonRequest( CSteamID *steamID ) = 0;
virtual bool GSSendDisconnect( CSteamID *steamID ) = 0;
virtual bool GSSendStatusResponse( CSteamID *steamID, int nSecondsConnected, int nSecondsSinceLast ) = 0;
virtual bool GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax ) = 0;
virtual int NClientGameIDAdd( int nGameID ) = 0;
virtual void RemoveClientGame( int nClientGameID ) = 0;
virtual void SetClientGameServer( int nClientGameID, uint32 unIPServer, uint16 usPortServer ) = 0;
virtual void Test_SuspendActivity() = 0;
virtual void Test_ResumeActivity() = 0;
virtual void Test_SendVACResponse( int unk1, void *unk2, int unk3 ) = 0;
virtual void Test_SetFakePrivateIP( uint32 ip ) = 0;
virtual void Test_SendBigMessage() = 0;
virtual bool Test_BBigMessageResponseReceived() = 0;
virtual void Test_SetPktLossPct( int unk1 ) = 0;
virtual void Test_SetForceTCP( bool unk1 ) = 0;
virtual void Test_Heartbeat() = 0;
virtual void Test_FakeDisconnect() = 0;
virtual EUniverse Test_GetEUniverse() = 0;
};
#endif // ISTEAMUSER001_H

65
sdk/steam/isteamuser002.h Normal file
View file

@ -0,0 +1,65 @@
#ifndef ISTEAMUSER002_H
#define ISTEAMUSER002_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
enum ELogonState
{
ELogonState_stub
};
class ICMCallback
{
public:
virtual ~ICMCallback() {}
virtual void OnLogonSuccess() = 0;
virtual void OnLogonFailure( EResult result ) = 0;
virtual void OnLoggedOff() = 0;
virtual void OnBeginLogonRetry() = 0;
virtual void HandleVACChallenge( int unk1, void *unk2, int unk3 ) = 0;
virtual void GSHandleClientApprove( CSteamID *steamID ) = 0;
virtual void GSHandleClientDeny( CSteamID *steamID, EDenyReason reason ) = 0;
virtual void GSHandleClientKick( CSteamID *steamID, EDenyReason reason ) = 0;
};
class ISteamUser002
{
public:
virtual void Init( ICMCallback *cmcallback, ISteam2Auth *steam2auth ) = 0;
virtual int ProcessCall( int unk ) = 0;
virtual void LogOn( CSteamID *steamID ) = 0;
virtual void LogOff() = 0;
virtual bool BLoggedOn() = 0;
virtual ELogonState GetLogonState() = 0;
virtual bool BConnected() = 0;
virtual int CreateAccount( const char *unk1, void *unk2, void *unk3, const char *unk4, int unk5, void *unk6 ) = 0;
virtual bool IsVACBanned( int nGameID ) = 0;
virtual bool RequireShowVACBannedMessage( int nGameID ) = 0;
virtual void AcknowledgeVACBanning( int nGameID ) = 0;
virtual bool GSSendLogonRequest( CSteamID *steamID ) = 0;
virtual bool GSSendDisconnect( CSteamID *steamID ) = 0;
virtual bool GSSendStatusResponse( CSteamID *steamID, int nSecondsConnected, int nSecondsSinceLast ) = 0;
virtual bool GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax, int cBotPlayers, int unGamePort, const char *pchServerName, const char *pchGameDir, const char *pchMapName, const char *pchVersion ) = 0;
virtual int NClientGameIDAdd( int nGameID ) = 0;
virtual void RemoveClientGame( int nClientGameID ) = 0;
virtual void SetClientGameServer( int nClientGameID, uint32 unIPServer, uint16 usPortServer ) = 0;
virtual void Test_SuspendActivity() = 0;
virtual void Test_ResumeActivity() = 0;
virtual void Test_SendVACResponse( int unk1, void *unk2, int unk3 ) = 0;
virtual void Test_SetFakePrivateIP( uint32 ip ) = 0;
virtual void Test_SendBigMessage() = 0;
virtual bool Test_BBigMessageResponseReceived() = 0;
virtual void Test_SetPktLossPct( int unk1 ) = 0;
virtual void Test_SetForceTCP( bool unk1 ) = 0;
virtual void Test_SetMaxUDPConnectionAttempts( int unk1 ) = 0;
virtual void Test_Heartbeat() = 0;
virtual void Test_FakeDisconnect() = 0;
virtual EUniverse Test_GetEUniverse() = 0;
};
#endif // ISTEAMUSER002_H

44
sdk/steam/isteamuser002_old.h Normal file
View file

@ -0,0 +1,44 @@
#ifndef ISTEAMUSER002_OLD_H
#define ISTEAMUSER002_OLD_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
class ISteamUser002_old
{
public:
virtual void Init( ICMCallback001 *cmcallback, ISteam2Auth *steam2auth ) = 0;
virtual int ProcessCall( int unk ) = 0;
virtual void LogOn( CSteamID *steamID ) = 0;
virtual void LogOff() = 0;
virtual bool BLoggedOn() = 0;
virtual bool BConnected() = 0;
virtual int CreateAccount( const char *unk1, void *unk2, void *unk3, const char *unk4, int unk5, void *unk6 ) = 0;
virtual bool IsVACBanned( int nGameID ) = 0;
virtual bool RequireShowVACBannedMessage( int nGameID ) = 0;
virtual void AcknowledgeVACBanning( int nGameID ) = 0;
virtual bool GSSendLogonRequest( CSteamID *steamID ) = 0;
virtual bool GSSendDisconnect( CSteamID *steamID ) = 0;
virtual bool GSSendStatusResponse( CSteamID *steamID, int nSecondsConnected, int nSecondsSinceLast ) = 0;
virtual bool GSSetStatus( int32 nAppIdServed, uint32 unServerFlags, int cPlayers, int cPlayersMax, int cBotPlayers, int unGamePort, const char *pchServerName, const char *pchGameDir, const char *pchMapName, const char *pchVersion ) = 0;
virtual int NClientGameIDAdd( int nGameID ) = 0;
virtual void RemoveClientGame( int nClientGameID ) = 0;
virtual void SetClientGameServer( int nClientGameID, uint32 unIPServer, uint16 usPortServer ) = 0;
virtual void Test_SuspendActivity() = 0;
virtual void Test_ResumeActivity() = 0;
virtual void Test_SendVACResponse( int unk1, void *unk2, int unk3 ) = 0;
virtual void Test_SetFakePrivateIP( uint32 ip ) = 0;
virtual void Test_SendBigMessage() = 0;
virtual bool Test_BBigMessageResponseReceived() = 0;
virtual void Test_SetPktLossPct( int unk1 ) = 0;
virtual void Test_SetForceTCP( bool unk1 ) = 0;
virtual void Test_SetMaxUDPConnectionAttempts( int unk1 ) = 0;
virtual void Test_Heartbeat() = 0;
virtual void Test_FakeDisconnect() = 0;
virtual EUniverse Test_GetEUniverse() = 0;
};
#endif // ISTEAMUSER002_OLD_H

7
sdk/steam/isteamuser004.h
View file

@ -5,14 +5,11 @@
#pragma once
#endif
enum EConfigSubTree {
enum EConfigSubTree
{
EConfigSubTree_stub
};
enum ELogonState {
ELogonState_stub
};
class ISteamUser004
{
public:

50
sdk/steam/isteamuser004_old.h Normal file
View file

@ -0,0 +1,50 @@
#ifndef ISTEAMUSER004_OLD_H
#define ISTEAMUSER004_OLD_H
#ifdef STEAM_WIN32
#pragma once
#endif
// this interface version is not found in public SDK archives, it is based on reversing old Linux binaries
#include "isteamfriends.h"
class ISteamUser004_old
{
public:
virtual bool BGetCallback( int *piCallback, uint8 **ppubParam, int *unk ) = 0;
virtual void FreeLastCallback() = 0;
virtual HSteamUser GetHSteamUser() = 0;
virtual void LogOn( CSteamID steamID ) = 0;
virtual void LogOff() = 0;
virtual bool BLoggedOn() = 0;
virtual ELogonState GetLogonState() = 0;
virtual bool BConnected() = 0;
virtual CSteamID GetSteamID() = 0;
virtual bool IsVACBanned( int nGameID ) = 0;
virtual bool RequireShowVACBannedMessage( int nGameID ) = 0;
virtual void AcknowledgeVACBanning( int nGameID ) = 0;
virtual int NClientGameIDAdd( int nGameID ) = 0;
virtual void RemoveClientGame( int nClientGameID ) = 0;
virtual void SetClientGameServer( int nClientGameID, uint32 unIPServer, uint16 usPortServer ) = 0;
virtual const char *GetPlayerName() = 0;
virtual void SetPlayerName( const char *pchPersonaName ) = 0;
virtual EPersonaState GetFriendStatus() = 0;
virtual void SetFriendStatus( EPersonaState ePersonaState ) = 0;
virtual bool AddFriend( CSteamID steamIDFriend ) = 0;
virtual bool RemoveFriend( CSteamID steamIDFriend ) = 0;
virtual bool HasFriend( CSteamID steamIDFriend ) = 0;
virtual EFriendRelationship GetFriendRelationship( CSteamID steamIDFriend ) = 0;
virtual EPersonaState GetFriendStatus( CSteamID steamIDFriend ) = 0;
virtual bool GetFriendGamePlayed( CSteamID steamIDFriend, int32 *pnGameID, uint32 *punGameIP, uint16 *pusGamePort ) = 0;
virtual const char *GetPlayerName( CSteamID steamIDFriend ) = 0;
virtual int32 AddFriendByName( const char *pchEmailOrAccountName ) = 0;
virtual void SetSteam2Ticket( uint8 *pubTicket, int cubTicket ) = 0;
virtual void AddServerNetAddress( uint32 unIP, uint16 unPort ) = 0;
virtual bool SetEmail( const char *pchEmail ) = 0;
virtual int GetSteamTicket( void *pBlob, int cbMaxBlob ) = 0;
};
#endif // ISTEAMUSER004_OLD_H

10
sdk/steam/steam_api.h
View file

@ -24,6 +24,11 @@
#include "isteamappdisableupdate.h"
#include "isteambilling.h"
#include "isteamclient.h"
#include "isteamclient001.h"
#include "isteamclient002.h"
#include "isteamclient003.h"
#include "isteamclient004.h"
#include "isteamclient005.h"
#include "isteamclient006.h"
#include "isteamclient007.h"
#include "isteamclient008.h"
@ -40,6 +45,10 @@
#include "isteamclient019.h"
#include "isteamclient020.h"
#include "isteamuser.h"
#include "isteamuser001.h"
#include "isteamuser002_old.h"
#include "isteamuser002.h"
#include "isteamuser004_old.h"
#include "isteamuser004.h"
#include "isteamuser005.h"
#include "isteamuser006.h"
@ -234,6 +243,7 @@
#include "isteamgameserver004.h"
#include "isteamgameserver003.h"
#include "isteamgameserver002.h"
#include "isteamgameserver001.h"
#include "isteamgameserverstats.h"
#include "isteamgamestats.h"