feat: make demoheader unique for every instance

Author: Krzyhau

src/InstanceIdentifier.cpp

@@ -0,0 +1,114 @@
+#include "InstanceIdentifier.hpp"
+
+#include "Event.hpp"
+
+#include <string>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <fcntl.h>
+#include <sys/file.h>
+#include <unistd.h>
+#endif
+
+
+std::string getInstanceLockFilePath(int index) {
+	std::string tempDir = std::filesystem::temp_directory_path().string();
+
+	std::string sarPath = Utils::GetSARPath();
+	size_t sarPathHash = std::hash<std::string>{}(sarPath);
+
+	return Utils::ssprintf("%s/sar_instance_%zu_%d.lock", tempDir.c_str(), sarPathHash, index);
+}
+
+#ifdef _WIN32
+
+HANDLE g_instanceLockFileHandle = INVALID_HANDLE_VALUE;
+
+bool tryClaimInstanceID(int index) {
+	auto handle = CreateFileA(getInstanceLockFilePath(index).c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+
+	if (handle == INVALID_HANDLE_VALUE) {
+		return false;
+	}
+
+	OVERLAPPED ol = {0};
+	if (!LockFileEx(handle, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, MAXDWORD, MAXDWORD, &ol)) {
+		CloseHandle(handle);
+		handle = INVALID_HANDLE_VALUE;
+		return false;
+	}
+
+	g_instanceLockFileHandle = handle;
+	return true;
+}
+
+void freeInstanceID() {
+	if (g_instanceLockFileHandle == INVALID_HANDLE_VALUE) {
+		return;
+	}
+
+	UnlockFile(g_instanceLockFileHandle, 0, 0, MAXDWORD, MAXDWORD);
+	CloseHandle(g_instanceLockFileHandle);
+	g_instanceLockFileHandle = INVALID_HANDLE_VALUE;
+}
+
+#else
+
+int g_instanceLockFileHandle = -1;
+
+bool tryClaimInstanceID(int index) {
+	auto handle = open(getInstanceLockFilePath(index).c_str(), O_RDWR | O_CREAT, 0666);
+
+	if (handle == -1) {
+		return false;
+	}
+
+	if (flock(handle, LOCK_EX | LOCK_NB) != 0) {
+		if (handle != -1) close(handle);
+		g_instanceLockFileHandle = -1;
+		return false;
+	}
+
+	g_instanceLockFileHandle = handle;
+	return true;
+}
+
+void freeInstanceID() {
+	if (g_instanceLockFileHandle == -1) {
+		return;
+	}
+	flock(g_instanceLockFileHandle, LOCK_UN);
+	close(g_instanceLockFileHandle);
+	g_instanceLockFileHandle = -1;
+}
+
+#endif
+
+
+int g_instanceID = -1;
+
+void InstanceIdentifier::Claim() {
+	const int MAX_INSTANCES = 128;
+	for (int i = 0; i < MAX_INSTANCES; i++) {
+		if (!tryClaimInstanceID(i)) {
+			continue;
+		}
+
+		g_instanceID = i;
+		return;
+	}
+}
+
+int InstanceIdentifier::GetID() {
+	return g_instanceID;
+}
+
+void InstanceIdentifier::Free() {
+	freeInstanceID();
+	g_instanceID = -1;
+}

src/InstanceIdentifier.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace InstanceIdentifier {
+	void Claim();
+	void Free();
+	int GetID();
+}

src/Modules/EngineDemoRecorder.cpp

@@ -21,6 +21,8 @@
 
 #include <cstdio>
 #include <filesystem>
+#include <Hook.hpp>
+#include <InstanceIdentifier.hpp>
 
 REDECL(EngineDemoRecorder::SetSignonState);
 REDECL(EngineDemoRecorder::StartRecording);
@@ -346,6 +348,30 @@ DETOUR_COMMAND(EngineDemoRecorder::record) {
 	}
 }
 
+Memory::Patch *g_StartupDemoFile_headerNamePatch;
+Memory::Patch *g_StartupDemoHeader_headerNamePatch;
+std::string g_uniqueDemoHeaderName;
+
+void patchDemoHeaderTempFileToBeUnique() {
+	int instanceID = InstanceIdentifier::GetID();
+	if (instanceID == 0) {
+		// no need to patch if we're the only instance
+		return;
+	}
+
+	g_uniqueDemoHeaderName = Utils::ssprintf("demoheader_%d.tmp", instanceID+1);
+
+	auto uniqueDemoHeaderName = g_uniqueDemoHeaderName.c_str();
+	auto uniqueDemoHeaderNamePtr = (unsigned char *)&uniqueDemoHeaderName;
+
+	g_StartupDemoFile_headerNamePatch = new Memory::Patch();
+	auto StartupDemoFile = Memory::Scan(engine->demorecorder->Name(), Offsets::StartupDemoFile);
+	g_StartupDemoFile_headerNamePatch->Execute(StartupDemoFile + Offsets::StartupDemoFile_HeaderName, uniqueDemoHeaderNamePtr, 4);
+	g_StartupDemoHeader_headerNamePatch = new Memory::Patch();
+	auto StartupDemoHeader = Memory::Scan(engine->demorecorder->Name(), Offsets::StartupDemoHeader);
+	g_StartupDemoHeader_headerNamePatch->Execute(StartupDemoHeader + Offsets::StartupDemoHeader_HeaderName, uniqueDemoHeaderNamePtr, 4);
+}
+
 bool EngineDemoRecorder::Init() {
 	auto disconnect = engine->cl->Original(Offsets::Disconnect);
 	auto demorecorder = Memory::DerefDeref<void *>(disconnect + Offsets::demorecorder);
@@ -363,6 +389,8 @@ bool EngineDemoRecorder::Init() {
 		this->m_bRecording = reinterpret_cast<bool *>((uintptr_t)demorecorder + Offsets::m_bRecording);
 
 		engine->net_time = Memory::Deref<double *>((uintptr_t)this->GetRecordingTick + Offsets::net_time);
+
+		patchDemoHeaderTempFileToBeUnique();
 	}
 
 	Command::Hook("stop", EngineDemoRecorder::stop_callback_hook, EngineDemoRecorder::stop_callback);
@@ -371,6 +399,11 @@ bool EngineDemoRecorder::Init() {
 	return this->hasLoaded = this->s_ClientDemoRecorder;
 }
 void EngineDemoRecorder::Shutdown() {
+	g_StartupDemoFile_headerNamePatch->Restore();
+	SAFE_DELETE(g_StartupDemoFile_headerNamePatch);
+	g_StartupDemoHeader_headerNamePatch->Restore();
+	SAFE_DELETE(g_StartupDemoHeader_headerNamePatch);
+
 	Interface::Delete(this->s_ClientDemoRecorder);
 	Command::Unhook("stop", EngineDemoRecorder::stop_callback);
 	Command::Unhook("record", EngineDemoRecorder::record_callback);

src/Offsets/Portal 2 9568.hpp

@@ -472,6 +472,14 @@ OFFSET_DEFAULT(Cmd_ShutdownOff, 3, 11)
 OFFSET_DEFAULT(Cmd_ShutdownOff2, 10, 10)
 
 
+// EngineDemoRecorder
+// "demoheader.tmp"
+SIGSCAN_DEFAULT(StartupDemoHeader, "56 8B F1 E8 ? ? ? ? 6A 00 6A 00 68 ? ? ? ? 8D", "53 83 EC 14 8B 5C 24 ? 53 E8 ? ? ? ? 8D 43 ?")
+OFFSET_DEFAULT(StartupDemoHeader_HeaderName, 13, 25)
+SIGSCAN_DEFAULT(StartupDemoFile, "55 8B EC 81 EC 18 02 00 00 53 8B D9 80", "55 89 E5 57 56 53 81 EC 3C 02 00 00 8B 5D ? 80 BB ? ? ? ? 00")
+OFFSET_DEFAULT(StartupDemoFile_HeaderName, 212, 184)
+
+
 // EngineDemoPlayer
 SIGSCAN_DEFAULT(InterpolateDemoCommand, "55 8B EC 83 EC 10 56 8B F1 8B 4D 10 57 8B BE B4 05 00 00 83 C1 04 89 75 F4 89 7D F0 E8 ? ? ? ? 8B 4D 14 83 C1 04",
                                         "55 57 56 53 83 EC 10 8B 44 24 24 8B 5C 24 2C 8B 88 B0 05 00 00 8B 44 24 30 8D 70 04 8D 90 9C 00 00 00 89 F0 F3 0F 10 40 04")

src/SAR.cpp

@@ -20,6 +20,7 @@
 #include "Features/SeasonalASCII.hpp"
 #include "Game.hpp"
 #include "Hook.hpp"
+#include "InstanceIdentifier.hpp"
 #include "Interface.hpp"
 #include "Modules.hpp"
 #include "Variable.hpp"
@@ -58,6 +59,7 @@ bool SAR::Load(CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerF
 		CrashHandler::Init();
 
 		curl_global_init(CURL_GLOBAL_ALL);
+		InstanceIdentifier::Claim();
 
 		tier1 = new Tier1();
 		if (tier1->Init()) {
@@ -245,6 +247,8 @@ void SAR::Unload() {
 		tier1->Shutdown();
 	}
 
+	InstanceIdentifier::Free();
+
 	SAFE_DELETE(sar.features)
 	SAFE_DELETE(sar.cheats)
 	SAFE_DELETE(sar.modules)