Merge branch 'dev'

Author: AceSLS

Makefile

@@ -45,13 +45,14 @@ install:
 
 zips: rebuild
 	@mkdir -p zips
-	7z a -mx9 -m9=lzma2 "zips/SLSsteam $(DATE).7z" "bin/SLSsteam.so" "setup.sh"
-	#Maybe should be somewhere else, but who cares. Does anyone even use this besides me?
-	7z a -mx9 -m9=lzma2 "zips/SLSsteam - SLSConfig $(DATE).7z" "$(HOME)/.config/SLSsteam/config.yaml"
-
+	7z a -mx9 -m9=lzma2 "zips/SLSsteam $(DATE).7z" "bin/SLSsteam.so" "setup.sh" "tools/SLScheevo"
 	#Compatibility for Github issues
-	7z a -mx9 -m9=lzma "zips/SLSsteam $(DATE).zip" "bin/SLSsteam.so" "setup.sh"
+	7z a -mx9 -m9=lzma "zips/SLSsteam $(DATE).zip" "bin/SLSsteam.so" "setup.sh" "tools/SLScheevo"
+
+zips-config:
 	7z a -mx9 -m9=lzma "zips/SLSsteam - SLSConfig $(DATE).zip" "$(HOME)/.config/SLSsteam/config.yaml"
+	#Compatibility for Github issues
+	7z a -mx9 -m9=lzma2 "zips/SLSsteam - SLSConfig $(DATE).7z" "$(HOME)/.config/SLSsteam/config.yaml"
 
 build: bin/SLSsteam.so
 rebuild: clean build

pkg/slssteam-git/PKGBUILD

@@ -16,6 +16,7 @@ optdepends=("steam-native"
 			"ccache")
 
 provides=("slssteam")
+conflicts=("slssteam")
 
 
 source=("git+$url#branch=dev")

pkg/slssteam/PKGBUILD

@@ -15,6 +15,7 @@ depends=("steam"
 optdepends=("steam-native")
 
 provides=("slssteam")
+conflicts=("slssteam-git")
 
 source=("https://github.com/AceSLS/SLSsteam/archive/refs/tags/$pkgver.tar.gz")
 makedepends=("gcc")

src/config.cpp

@@ -47,6 +47,9 @@ static const char* defaultConfig =
 "DenuvoGames:\n\n"
 "#Spoof Denuvo Games owner instead of blocking them\n"
 "DenuvoSpoof: no\n\n"
+"#Pretends Steam never received an Encrypted AppTicket, so it\n"
+"#only gets saved to the cache instead of \"being used up\"\n"
+"BlockEncryptedAppTickets: no\n\n"
 "#Automatically disable SLSsteam when steamclient.so does not match a predefined file hash that is known to work\n"
 "#You should enable this if you're planing to use SLSsteam with Steam Deck's gamemode\n"
 "SafeMode: no\n\n"
@@ -57,6 +60,15 @@ static const char* defaultConfig =
 "WarnHashMissmatch: no\n\n"
 "#Notify when SLSsteam is done initializing\n"
 "NotifyInit: yes\n\n"
+"#Log levels:\n"
+"#Once = 0\n"
+"#Debug = 1\n"
+"#Info = 2\n"
+"#NotifyShort = 3\n"
+"#NotifyLong = 4\n"
+"#Warn = 5\n"
+"#None = 6\n"
+"LogLevel: 2\n\n"
 "#Logs all calls to Steamworks (this makes the logfile huge! Only useful for debugging/analyzing\n"
 "ExtendedLogging: no";
 
@@ -147,6 +159,8 @@ bool CConfig::loadSettings()
 	warnHashMissmatch = getSetting<bool>(node, "WarnHashMissmatch", false);
 	notifyInit = getSetting<bool>(node, "NotifyInit", true);
 	extendedLogging = getSetting<bool>(node, "ExtendedLogging", false);
+	logLevel = getSetting<unsigned int>(node, "LogLevel", 2);
+	blockEncryptedAppTickets = getSetting<bool>(node, "BlockEncryptedAppTickets", false);
 	denuvoSpoof = getSetting<bool>(node, "DenuvoSpoof", false);
 
 	//TODO: Create smart logging function to log them automatically via getSetting
@@ -159,7 +173,9 @@ bool CConfig::loadSettings()
 	g_pLog->info("WarnHashMissmatch: %i\n", warnHashMissmatch);
 	g_pLog->info("NotifyInit: %i\n", notifyInit);
 	g_pLog->info("ExtendedLogging: %i\n", extendedLogging);
+	g_pLog->info("LogLevel: %i\n", logLevel);
 	g_pLog->info("DenuvoSpoof: %i\n", denuvoSpoof);
+	g_pLog->info("BlockEncryptedAppTickets: %i\n", blockEncryptedAppTickets);
 
 	//TODO: Create function to parse these kinda nodes, instead of c+p them
 	const auto appIdsNode = node["AppIds"];
@@ -217,7 +233,7 @@ bool CConfig::loadSettings()
 
 				CDlcData data;
 				data.parentId = parentId;
-				g_pLog->debug("Adding DlcData for %u\n", parentId);
+				g_pLog->info("Adding DlcData for %u\n", parentId);
 
 				for(auto& dlc : app.second)
 				{
@@ -226,7 +242,7 @@ bool CConfig::loadSettings()
 					const std::string dlcName = dlc.second.as<std::string>();
 
 					data.dlcIds[dlcId] = dlcName;
-					g_pLog->debug("DlcId %u -> %s\n", dlcId, dlcName.c_str());
+					g_pLog->info("DlcId %u -> %s\n", dlcId, dlcName.c_str());
 				}
 
 				dlcData[parentId] = data;
@@ -259,7 +275,7 @@ bool CConfig::loadSettings()
 					denuvoGames[steamId].emplace(appId);
 
 					//Again, not loggin SteamId because of privacy
-					g_pLog->debug("Added DenuvoGame %u\n", appId);
+					g_pLog->info("Added DenuvoGame %u\n", appId);
 				}
 			}
 			catch (...)

src/config.hpp

@@ -28,6 +28,7 @@ class CConfig {
 	std::unordered_map<uint32_t, CDlcData> dlcData;
 	//SteamId, AppIds tuple
 	std::unordered_map<uint32_t, std::unordered_set<uint32_t>> denuvoGames;
+	bool blockEncryptedAppTickets;
 	bool denuvoSpoof;
 
 	bool disableFamilyLock;
@@ -38,6 +39,7 @@ class CConfig {
 	bool notifications;
 	bool warnHashMissmatch;
 	bool notifyInit;
+	unsigned int logLevel;
 	bool extendedLogging;
 
 	std::string getDir();

src/feats/apps.cpp

@@ -0,0 +1,128 @@
+#include "apps.hpp"
+
+#include "../sdk/IClientApps.hpp"
+
+#include "../config.hpp"
+#include "../globals.hpp"
+
+bool Apps::applistRequested;
+std::map<uint32_t, int> Apps::appIdOwnerOverride;
+
+bool Apps::checkAppOwnership(uint32_t appId, CAppOwnershipInfo* pInfo)
+{
+	//Wait Until GetSubscribedApps gets called once to let Steam request and populate legit data first.
+	//Afterwards modifying should hopefully not affect false positives anymore
+	if (!applistRequested || !pInfo || !g_currentSteamId)
+	{
+		return false;
+	}
+
+	uint32_t ownerOverride = g_currentSteamId;
+	const uint32_t denuvoOwner = g_config.getDenuvoGameOwner(appId);
+
+	//Do not modify Denuvo enabled Games
+	if (denuvoOwner && denuvoOwner != g_currentSteamId)
+	{
+		if (g_config.denuvoSpoof)
+		{
+			ownerOverride = denuvoOwner;
+		}
+		else
+		{
+			//Would love to log the SteamId, but for users anonymity I won't
+			g_pLog->once("Skipping %u because it's a Denuvo game from someone else\n", appId);
+			return false;
+		}
+	}
+
+	//Doing that might be not worth it since this will most likely be easier to mantain
+	//TODO: Backtrace those 4 calls and only patch the really necessary ones since this might be prone to breakage
+	if (g_config.disableFamilyLock && appIdOwnerOverride.count(appId) && appIdOwnerOverride.at(appId) < 4)
+	{
+		ownerOverride = 1;
+		appIdOwnerOverride[appId]++;
+	}
+
+	if (!g_config.shouldExcludeAppId(appId) && (g_config.isAddedAppId(appId) || (g_config.playNotOwnedGames && !pInfo->purchased)))
+	{
+		//Changing the purchased field is enough, but just for nicety in the Steamclient UI we change the owner too
+		pInfo->ownerSteamId = ownerOverride;
+		pInfo->familyShared = ownerOverride != g_currentSteamId;
+
+		pInfo->purchased = true;
+		//Unnessecary but whatever
+		pInfo->permanent = !pInfo->familyShared;
+
+		//Found in backtrace
+		pInfo->releaseState = 4;
+		pInfo->field10_0x25 = 0;
+		//Seems to do nothing in particular, some dlc have this as 1 so I uncomented this for now. Might be free stuff?
+		//pOwnershipInfo->field27_0x36 = 1;
+
+		g_config.addAdditionalAppId(appId);
+	}
+
+	//Returning false after we modify data shouldn't cause any problems because it should just get discarded
+
+	if (!g_pClientApps)
+		return false;
+
+	auto type = g_pClientApps->getAppType(appId);
+	if (type == APPTYPE_DLC) //Don't touch DLC here, otherwise downloads might break. Hopefully this won't decrease compatibility
+	{
+		return false;
+	}
+
+	if (g_config.automaticFilter)
+	{
+		switch(type)
+		{
+			case APPTYPE_APPLICATION:
+			case APPTYPE_GAME:
+				break;
+
+			default:
+				return false;
+		}
+	}
+
+	return true;
+}
+
+void Apps::getSubscribedApps(uint32_t* appList, size_t size, uint32_t& count)
+{
+	//Valve calls this function twice, once with size of 0 then again
+	if (!size || !appList)
+	{
+		count = count + g_config.addedAppIds.size();
+		return;
+	}
+
+	//TODO: Maybe Add check if AppId already in list before blindly appending
+	for(auto& appId : g_config.addedAppIds)
+	{
+		appList[count++] = appId;
+	}
+
+	applistRequested = true;
+}
+
+void Apps::launchApp(uint32_t appId)
+{
+	appIdOwnerOverride[appId] = 0;
+}
+
+bool Apps::shouldDisableCloud(uint32_t appId)
+{
+	return g_config.isAddedAppId(appId);
+}
+
+bool Apps::shouldDisableCDKey(uint32_t appId)
+{
+	return g_config.isAddedAppId(appId);
+}
+
+bool Apps::shouldDisableUpdates(uint32_t appId)
+{
+	return g_config.isAddedAppId(appId);
+}

src/feats/apps.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "../sdk/CAppOwnershipInfo.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <map>
+
+
+namespace Apps
+{
+	extern bool applistRequested;
+	extern std::map<uint32_t, int> appIdOwnerOverride;
+
+	bool checkAppOwnership(uint32_t appId, CAppOwnershipInfo* info);
+	void getSubscribedApps(uint32_t* appList, size_t size, uint32_t& count);
+	void launchApp(uint32_t appId);
+
+	bool shouldDisableCloud(uint32_t appId);
+	bool shouldDisableCDKey(uint32_t appId);
+	bool shouldDisableUpdates(uint32_t appId);
+};

src/feats/dlc.cpp

@@ -0,0 +1,81 @@
+#include "dlc.hpp"
+
+#include "../sdk/IClientAppManager.hpp"
+
+#include "../config.hpp"
+
+
+bool DLC::isDlcEnabled(uint32_t appId)
+{
+	//TODO: Add check for legit ownership to allow toggle on/off
+	return !g_config.shouldExcludeAppId(appId);
+}
+
+bool DLC::isSubscribed(uint32_t appId)
+{
+	return !g_config.shouldExcludeAppId(appId);
+}
+
+bool DLC::isAppDlcInstalled(uint32_t appId, uint32_t dlcId)
+{
+	//Do not pretend things are installed while downloading Apps, otherwise downloads will break for some of them
+	auto state = g_pClientAppManager->getAppInstallState(appId);
+	if (state & APPSTATE_DOWNLOADING || state & APPSTATE_INSTALLING)
+	{
+		g_pLog->once("Skipping DlcId %u because AppId %u has AppState %i\n", dlcId, appId, state);
+		return false;
+	}
+
+	if (g_config.shouldExcludeAppId(dlcId))
+	{
+		return false;
+	}
+
+	return true;
+}
+
+bool DLC::userSubscribedInTicket(uint32_t appId)
+{
+	//Might want to compare the steamId param to the g_currentSteamId in the future
+	//Although not doing that might also work for Dedicated servers?
+	return !g_config.shouldExcludeAppId(appId);
+}
+
+uint32_t DLC::getDlcCount(uint32_t appId)
+{
+	if (g_config.dlcData.contains(appId))
+	{
+		return g_config.dlcData[appId].dlcIds.size();
+	}
+
+	return 0;
+}
+
+bool DLC::getDlcDataByIndex(uint32_t appId, int index, uint32_t* dlcId, bool* available, char* dlcName, size_t& dlcNameLen)
+{
+	if (!dlcId || !available || !dlcName)
+	{
+		return false;
+	}
+
+	if (g_config.dlcData.contains(appId))
+	{
+		auto& data = g_config.dlcData[appId];
+		auto dlc = std::next(data.dlcIds.begin(), index);
+
+		*dlcId = dlc->first;
+		*available = true;
+
+		//No clue if we have to check for errors during printf since the devs hopefully didn't fuck
+		//up the dlcNameLen. Who knows though
+		snprintf(dlcName, dlcNameLen, "%s", dlc->second.c_str());
+
+		return true;
+	}
+	else if (!g_config.shouldExcludeAppId(*dlcId))
+	{
+		*available = true;
+	}
+
+	return false;
+}

src/feats/dlc.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+
+namespace DLC
+{
+	bool isDlcEnabled(uint32_t appId);
+	bool isSubscribed(uint32_t appId);
+	bool isAppDlcInstalled(uint32_t appId, uint32_t dlcId);
+	bool userSubscribedInTicket(uint32_t appId);
+
+	uint32_t getDlcCount(uint32_t appId);
+	bool getDlcDataByIndex(uint32_t appId, int index, uint32_t* dlcId, bool* available, char* dlcName, size_t& dlcNameLen);
+}