big refactor (#171)v1.10.0-rc1

* use in-file macros rather than global funcs for registering dll load callbacks

* move more things to macros

* fix debug crashes

* move sqvm funcs to sq managers

* get rid of context file

* refactor some squirrel stuff and ingame compilation error message

* move tier0 and playlist funcs to namespaces

* uiscript_reset concommand: don't loop forever if compilation fails

* improve showing console for ui script compile errors

* standardise concommand func naming in c++

* use lambdas for dll load callbacks so intellisense shits itself less

* use cvar change callbacks for unescaping ns_server_name and ns_server_desc

* add proper helpstrings to masterserver cvars

* add cvar help and find

* allow parsing of convar flags from string

* normalise mod fs paths to be lowercase

* move hoststate to its own file and add host_init hooks

* better IsFlagSet def

* replace files in ReadFromCache

* rename g_ModManager to g_pModManager

* formatting changes

* make cvar print work on dedi, move demo fix stuff, add findflags

* add proper map autocompletes and maps command

* formatting changes

* separate gameutils into multiple r2 headers

* Update keyvalues.cpp

* move sqvm funcs into wrappers in the manager class

* remove unnecessary header files

* lots of cleanup and starting moving to new hooking macros

* update more stuff to new hook macros

* rename project folder (:tf: commit log)

* fix up postbuild commands to use relative dir

* almost fully replaced hooking lib

* completely remove old hooking

* add nsprefix because i forgot to include it

* move exploit prevention and limits code out of serverauthentication, and have actual defs for CBasePlayer

* use modular ServerPresence system for registering servers

* add new memory lib

* accidentally pushed broke code oops

* lots of stuff idk

* implement some more prs

* improve rpakfilesystem

* fix line endings on vcxproj

* Revert "fix line endings on vcxproj"

This reverts commit 4ff7d022d2602c2dba37beba8b8df735cf5cd7d9.

* add more prs

* i swear i committed these how are they not there

* Add ability to load Datatables from files (#238)

* first version of kinda working custom datatables

* Fix copy error

* Finish custom datatables

* Fix Merge

* Fix line endings

* Add fallback to rpak when ns_prefere_datatable_from_disk is true

* fix typo

* Bug fixess

* Fix Function Registration hook

* Set convar value

* Fix Client and Ui VM

* enable server auth with ms agian

* Add Filters

* FIx unused import

* Merge remote-tracking branch 'upsteam/bobs-big-refactor-pr' into datatables

Co-authored-by: RoyalBlue1 <realEmail@veryRealURL.com>

* Add some changes from main to refactor (#243)

* Add PR template

* Update CI folder location

* Delete startup args txt files

* Fix line endings (hopefully) (#244)

* Fix line endings (hopefully)

* Fix more line endings

* Update refactor (#250)

* Add PR template

* Update CI folder location

* Delete startup args txt files

* Add editorconfig file (#246)

* Add editorconfig file

It's a cross-editor compatible config file that defines certain editor
behaviour (e.g. adding/removing newline at end of file)

It is supported by major editors like Visual Studio (Code) and by
version control  providers like GitHub.

Should end the constant adding/removing of final newline in PRs

* More settings

- unicode by default
- trim newlines
- use tabs for indentation (ugh)

* Ignore folder rename (#245)

* Hot reload banlist on player join (#233)

* added banlist hotreload

* fix formatting

* didnt append, cleared whole file oopsie

* unfuckedunban not rewriting file

* fixed not checking for new line

Co-authored-by: ScureX <47725553+ScureX@users.noreply.github.com>

* Refactor cleanup (#256)

* Fix indentation

* Fix path in clang-format command in readme

* Refactor cleanup (some formatting fixes) (#257)

* Fix some formatting

* More formatting fixes

* add scriptdatatable.cpp rewrite

* Some formatting fixes (#260)

* More formatting stuff (#261)

* various formatting changes and fixes

* Fix changed icon (#264)

* clang format, fix issues with server registration and rpak loading

* fix more formatting

* update postbuild step

* set launcher directory and error on fail creating log files

* change some stuff in exploitfixes

* only unrestrict dev commands when commandline flag is present

* fix issues with cvar flag commit

* fixup command flags better and reformat

* bring up to date with main

* fixup formatting

* improve cvar flag fixup and remove temp thing from findflags

* set serverfilter better

* avoid ptr decay when setting auth token

* add more entity functions

* Fix the MS server registration issues. (#285)

* Port ms presence reporter to std::async

* Fix crash due to std::optional being assigned nullptr.

* Fix formatting.

* Wait 20 seconds if MS returns DUPLICATE_SERVER.

* Change PERSISTENCE_MAX_SIZE to fix player authentication (#287)

The size check added in the refactor was incorrect:

- 56306: expected pdata size based on the pdef
- 512: allowance for trailing junk (r2 adds 137 bytes of trailing junk)
- 100: for some wiggle room

Co-Authored-By: pg9182 <96569817+pg9182@users.noreply.github.com>

* change miscserverscript to use actual entity arguments rather than
player index jank

* Fix token clearing hook (#290)

A certain someone forgot to put an `0x` in front of their hex number, meaning the offset is wrong.
This would cause token to be leaked again

Co-authored-by: Maya <malte.hoermeyer@web.de>
Co-authored-by: RoyalBlue1 <realEmail@veryRealURL.com>
Co-authored-by: GeckoEidechse <40122905+GeckoEidechse@users.noreply.github.com>
Co-authored-by: ScureX <47725553+ScureX@users.noreply.github.com>
Co-authored-by: Erlite <ys.aameziane@gmail.com>
Co-authored-by: Emma Miler <emma.pi@protonmail.com>
Co-authored-by: pg9182 <96569817+pg9182@users.noreply.github.com>

1 files changed, 272 insertions, 118 deletions

diff --git a/NorthstarDLL/hooks.cpp b/NorthstarDLL/hooks.cpp
index 72ae727a..cca1d986 100644
--- a/NorthstarDLL/hooks.cpp
+++ b/NorthstarDLL/hooks.cpp
@@ -1,61 +1,193 @@
 #include "pch.h"
-#include "hooks.h"
-#include "hookutils.h"
-#include "sigscanning.h"
 #include "dedicated.h"
 
+#include <iostream>
 #include <wchar.h>
 #include <iostream>
 #include <vector>
 #include <fstream>
 #include <sstream>
 #include <filesystem>
+#include <Psapi.h>
 
-typedef LPSTR (*GetCommandLineAType)();
-LPSTR GetCommandLineAHook();
+AUTOHOOK_INIT()
 
-typedef HMODULE (*LoadLibraryExAType)(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
-HMODULE LoadLibraryExAHook(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
+// called from the ON_DLL_LOAD macros
+__dllLoadCallback::__dllLoadCallback(
+	eDllLoadCallbackSide side, const std::string dllName, DllLoadCallbackFuncType callback, std::string uniqueStr, std::string reliesOn)
+{
+	// parse reliesOn array from string
+	std::vector<std::string> reliesOnArray;
 
-typedef HMODULE (*LoadLibraryAType)(LPCSTR lpLibFileName);
-HMODULE LoadLibraryAHook(LPCSTR lpLibFileName);
+	if (reliesOn.length() && reliesOn[0] != '(')
+	{
+		reliesOnArray.push_back(reliesOn);
+	}
+	else
+	{
+		// follows the format (tag, tag, tag)
+		std::string sCurrentTag;
+		for (int i = 1; i < reliesOn.length(); i++)
+		{
+			if (!isspace(reliesOn[i]))
+			{
+				if (reliesOn[i] == ',' || reliesOn[i] == ')')
+				{
+					reliesOnArray.push_back(sCurrentTag);
+					sCurrentTag = "";
+				}
+				else
+					sCurrentTag += reliesOn[i];
+			}
+		}
+	}
 
-typedef HMODULE (*LoadLibraryExWType)(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
-HMODULE LoadLibraryExWHook(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags);
+	switch (side)
+	{
+	case eDllLoadCallbackSide::UNSIDED:
+	{
+		AddDllLoadCallback(dllName, callback, uniqueStr, reliesOnArray);
+		break;
+	}
 
-typedef HMODULE (*LoadLibraryWType)(LPCWSTR lpLibFileName);
-HMODULE LoadLibraryWHook(LPCWSTR lpLibFileName);
+	case eDllLoadCallbackSide::CLIENT:
+	{
+		AddDllLoadCallbackForClient(dllName, callback, uniqueStr, reliesOnArray);
+		break;
+	}
 
-GetCommandLineAType GetCommandLineAOriginal;
-LoadLibraryExAType LoadLibraryExAOriginal;
-LoadLibraryAType LoadLibraryAOriginal;
-LoadLibraryExWType LoadLibraryExWOriginal;
-LoadLibraryWType LoadLibraryWOriginal;
+	case eDllLoadCallbackSide::DEDICATED_SERVER:
+	{
+		AddDllLoadCallbackForDedicatedServer(dllName, callback, uniqueStr, reliesOnArray);
+		break;
+	}
+	}
+}
 
-void InstallInitialHooks()
+void __fileAutohook::Dispatch()
 {
-	if (MH_Initialize() != MH_OK)
-		spdlog::error("MH_Initialize (minhook initialization) failed");
+	for (__autohook* hook : hooks)
+		hook->Dispatch();
+}
+
+void __fileAutohook::DispatchForModule(const char* pModuleName)
+{
+	const int iModuleNameLen = strlen(pModuleName);
+
+	for (__autohook* hook : hooks)
+		if ((hook->iAddressResolutionMode == __autohook::OFFSET_STRING && !strncmp(pModuleName, hook->pAddrString, iModuleNameLen)) ||
+			(hook->iAddressResolutionMode == __autohook::PROCADDRESS && !strcmp(pModuleName, hook->pModuleName)))
+			hook->Dispatch();
+}
 
-	HookEnabler hook;
-	ENABLER_CREATEHOOK(
-		hook, reinterpret_cast<void*>(&GetCommandLineA), &GetCommandLineAHook, reinterpret_cast<LPVOID*>(&GetCommandLineAOriginal));
-	ENABLER_CREATEHOOK(
-		hook, reinterpret_cast<void*>(&LoadLibraryExA), &LoadLibraryExAHook, reinterpret_cast<LPVOID*>(&LoadLibraryExAOriginal));
-	ENABLER_CREATEHOOK(hook, reinterpret_cast<void*>(&LoadLibraryA), &LoadLibraryAHook, reinterpret_cast<LPVOID*>(&LoadLibraryAOriginal));
-	ENABLER_CREATEHOOK(
-		hook, reinterpret_cast<void*>(&LoadLibraryExW), &LoadLibraryExWHook, reinterpret_cast<LPVOID*>(&LoadLibraryExWOriginal));
-	ENABLER_CREATEHOOK(hook, reinterpret_cast<void*>(&LoadLibraryW), &LoadLibraryWHook, reinterpret_cast<LPVOID*>(&LoadLibraryWOriginal));
+ManualHook::ManualHook(const char* funcName, LPVOID func) : pHookFunc(func), ppOrigFunc(nullptr)
+{
+	const int iFuncNameStrlen = strlen(funcName);
+	pFuncName = new char[iFuncNameStrlen];
+	memcpy(pFuncName, funcName, iFuncNameStrlen);
 }
 
-LPSTR GetCommandLineAHook()
+ManualHook::ManualHook(const char* funcName, LPVOID* orig, LPVOID func) : pHookFunc(func), ppOrigFunc(orig)
+{
+	const int iFuncNameStrlen = strlen(funcName);
+	pFuncName = new char[iFuncNameStrlen];
+	memcpy(pFuncName, funcName, iFuncNameStrlen);
+}
+
+bool ManualHook::Dispatch(LPVOID addr, LPVOID* orig)
+{
+	if (orig)
+		ppOrigFunc = orig;
+
+	if (MH_CreateHook(addr, pHookFunc, ppOrigFunc) == MH_OK)
+	{
+		if (MH_EnableHook(addr) == MH_OK)
+		{
+			spdlog::info("Enabling hook {}", pFuncName);
+			return true;
+		}
+		else
+			spdlog::error("MH_EnableHook failed for function {}", pFuncName);
+	}
+	else
+		spdlog::error("MH_CreateHook failed for function {}", pFuncName);
+
+	return false;
+}
+
+// dll load callback stuff
+// this allows for code to register callbacks to be run as soon as a dll is loaded, mainly to allow for patches to be made on dll load
+struct DllLoadCallback
+{
+	std::string dll;
+	DllLoadCallbackFuncType callback;
+	std::string tag;
+	std::vector<std::string> reliesOn;
+	bool called;
+};
+
+// HACK: declaring and initialising this vector at file scope crashes on debug builds due to static initialisation order
+// using a static var like this ensures that the vector is initialised lazily when it's used
+std::vector<DllLoadCallback>& GetDllLoadCallbacks()
+{
+	static std::vector<DllLoadCallback> vec = std::vector<DllLoadCallback>();
+	return vec;
+}
+
+void AddDllLoadCallback(std::string dll, DllLoadCallbackFuncType callback, std::string tag, std::vector<std::string> reliesOn)
+{
+	DllLoadCallback& callbackStruct = GetDllLoadCallbacks().emplace_back();
+
+	callbackStruct.dll = dll;
+	callbackStruct.callback = callback;
+	callbackStruct.tag = tag;
+	callbackStruct.reliesOn = reliesOn;
+	callbackStruct.called = false;
+}
+
+void AddDllLoadCallbackForDedicatedServer(
+	std::string dll, DllLoadCallbackFuncType callback, std::string tag, std::vector<std::string> reliesOn)
+{
+	if (!IsDedicatedServer())
+		return;
+
+	AddDllLoadCallback(dll, callback, tag, reliesOn);
+}
+
+void AddDllLoadCallbackForClient(std::string dll, DllLoadCallbackFuncType callback, std::string tag, std::vector<std::string> reliesOn)
+{
+	if (IsDedicatedServer())
+		return;
+
+	AddDllLoadCallback(dll, callback, tag, reliesOn);
+}
+
+void MakeHook(LPVOID pTarget, LPVOID pDetour, void* ppOriginal, const char* pFuncName)
+{
+	char* pStrippedFuncName = (char*)pFuncName;
+	// strip & char from funcname
+	if (*pStrippedFuncName == '&')
+		pStrippedFuncName++;
+
+	if (MH_CreateHook(pTarget, pDetour, (LPVOID*)ppOriginal) == MH_OK)
+	{
+		if (MH_EnableHook(pTarget) == MH_OK)
+			spdlog::info("Enabling hook {}", pStrippedFuncName);
+		else
+			spdlog::error("MH_EnableHook failed for function {}", pStrippedFuncName);
+	}
+	else
+		spdlog::error("MH_CreateHook failed for function {}", pStrippedFuncName);
+}
+
+AUTOHOOK_ABSOLUTEADDR(_GetCommandLineA, GetCommandLineA, LPSTR, WINAPI, ())
 {
 	static char* cmdlineModified;
 	static char* cmdlineOrg;
 
 	if (cmdlineOrg == nullptr || cmdlineModified == nullptr)
 	{
-		cmdlineOrg = GetCommandLineAOriginal();
+		cmdlineOrg = _GetCommandLineA();
 		bool isDedi = strstr(cmdlineOrg, "-dedicated"); // well, this one has to be a real argument
 		bool ignoreStartupArgs = strstr(cmdlineOrg, "-nostartupargs");
 
@@ -111,77 +243,86 @@ LPSTR GetCommandLineAHook()
 	return cmdlineModified;
 }
 
-// dll load callback stuff
-// this allows for code to register callbacks to be run as soon as a dll is loaded, mainly to allow for patches to be made on dll load
-struct DllLoadCallback
-{
-	std::string dll;
-	DllLoadCallbackFuncType callback;
-	bool called;
-};
-
-std::vector<DllLoadCallback*> dllLoadCallbacks;
-
-void AddDllLoadCallback(std::string dll, DllLoadCallbackFuncType callback)
-{
-	DllLoadCallback* callbackStruct = new DllLoadCallback;
-	callbackStruct->dll = dll;
-	callbackStruct->callback = callback;
-	callbackStruct->called = false;
-
-	dllLoadCallbacks.push_back(callbackStruct);
-}
-
-void AddDllLoadCallbackForDedicatedServer(std::string dll, DllLoadCallbackFuncType callback)
-{
-	if (!IsDedicatedServer())
-		return;
-
-	DllLoadCallback* callbackStruct = new DllLoadCallback;
-	callbackStruct->dll = dll;
-	callbackStruct->callback = callback;
-	callbackStruct->called = false;
-
-	dllLoadCallbacks.push_back(callbackStruct);
-}
-
-void AddDllLoadCallbackForClient(std::string dll, DllLoadCallbackFuncType callback)
-{
-	if (IsDedicatedServer())
-		return;
-
-	DllLoadCallback* callbackStruct = new DllLoadCallback;
-	callbackStruct->dll = dll;
-	callbackStruct->callback = callback;
-	callbackStruct->called = false;
-
-	dllLoadCallbacks.push_back(callbackStruct);
-}
-
+std::vector<std::string> calledTags;
 void CallLoadLibraryACallbacks(LPCSTR lpLibFileName, HMODULE moduleAddress)
 {
-	for (auto& callbackStruct : dllLoadCallbacks)
+	CModule cModule(moduleAddress);
+
+	while (true)
 	{
-		if (!callbackStruct->called &&
-			strstr(lpLibFileName + (strlen(lpLibFileName) - callbackStruct->dll.length()), callbackStruct->dll.c_str()) != nullptr)
+		bool bDoneCalling = true;
+
+		for (auto& callbackStruct : GetDllLoadCallbacks())
 		{
-			callbackStruct->callback(moduleAddress);
-			callbackStruct->called = true;
+			if (!callbackStruct.called && fs::path(lpLibFileName).filename() == fs::path(callbackStruct.dll).filename())
+			{
+				bool bShouldContinue = false;
+
+				if (!callbackStruct.reliesOn.empty())
+				{
+					for (std::string tag : callbackStruct.reliesOn)
+					{
+						if (std::find(calledTags.begin(), calledTags.end(), tag) == calledTags.end())
+						{
+							bDoneCalling = false;
+							bShouldContinue = true;
+							break;
+						}
+					}
+				}
+
+				if (bShouldContinue)
+					continue;
+
+				callbackStruct.callback(moduleAddress);
+				calledTags.push_back(callbackStruct.tag);
+				callbackStruct.called = true;
+			}
 		}
+
+		if (bDoneCalling)
+			break;
 	}
 }
 
 void CallLoadLibraryWCallbacks(LPCWSTR lpLibFileName, HMODULE moduleAddress)
 {
-	for (auto& callbackStruct : dllLoadCallbacks)
+	CModule cModule(moduleAddress);
+
+	while (true)
 	{
-		std::wstring wcharStrDll = std::wstring(callbackStruct->dll.begin(), callbackStruct->dll.end());
-		const wchar_t* callbackDll = wcharStrDll.c_str();
-		if (!callbackStruct->called && wcsstr(lpLibFileName + (wcslen(lpLibFileName) - wcharStrDll.length()), callbackDll) != nullptr)
+		bool bDoneCalling = true;
+
+		for (auto& callbackStruct : GetDllLoadCallbacks())
 		{
-			callbackStruct->callback(moduleAddress);
-			callbackStruct->called = true;
+			if (!callbackStruct.called && fs::path(lpLibFileName).filename() == fs::path(callbackStruct.dll).filename())
+			{
+				bool bShouldContinue = false;
+
+				if (!callbackStruct.reliesOn.empty())
+				{
+					for (std::string tag : callbackStruct.reliesOn)
+					{
+						if (std::find(calledTags.begin(), calledTags.end(), tag) == calledTags.end())
+						{
+							bDoneCalling = false;
+							bShouldContinue = true;
+							break;
+						}
+					}
+				}
+
+				if (bShouldContinue)
+					continue;
+
+				callbackStruct.callback(moduleAddress);
+				calledTags.push_back(callbackStruct.tag);
+				callbackStruct.called = true;
+			}
 		}
+
+		if (bDoneCalling)
+			break;
 	}
 }
 
@@ -208,65 +349,78 @@ void CallAllPendingDLLLoadCallbacks()
 	}
 }
 
-HMODULE LoadLibraryExAHook(LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
+// clang-format off
+AUTOHOOK_ABSOLUTEADDR(_LoadLibraryExA, LoadLibraryExA,
+HMODULE, WINAPI, (LPCSTR lpLibFileName, HANDLE hFile, DWORD dwFlags))
+// clang-format on
 {
+	HMODULE moduleAddress;
+
+	// replace xinput dll with one that has ASLR
 	if (!strncmp(lpLibFileName, "XInput1_3.dll", 14))
 	{
-		HMODULE moduleAddress = LoadLibraryExAOriginal("XInput9_1_0.dll", hFile, dwFlags);
-		if (moduleAddress)
-		{
-			CallLoadLibraryACallbacks(lpLibFileName, moduleAddress);
-		}
-		else
+		moduleAddress = _LoadLibraryExA("XInput9_1_0.dll", hFile, dwFlags);
+
+		if (!moduleAddress)
 		{
 			MessageBoxA(0, "Could not find XInput9_1_0.dll", "Northstar", MB_ICONERROR);
 			exit(-1);
+
+			return nullptr;
 		}
-		return moduleAddress;
 	}
 	else
-	{
-		HMODULE moduleAddress = LoadLibraryExAOriginal(lpLibFileName, hFile, dwFlags);
-		if (moduleAddress)
-		{
-			CallLoadLibraryACallbacks(lpLibFileName, moduleAddress);
-		}
-		return moduleAddress;
-	}
+		moduleAddress = _LoadLibraryExA(lpLibFileName, hFile, dwFlags);
+
+	if (moduleAddress)
+		CallLoadLibraryACallbacks(lpLibFileName, moduleAddress);
+
+	return moduleAddress;
 }
 
-HMODULE LoadLibraryAHook(LPCSTR lpLibFileName)
+// clang-format off
+AUTOHOOK_ABSOLUTEADDR(_LoadLibraryA, LoadLibraryA,
+HMODULE, WINAPI, (LPCSTR lpLibFileName))
+// clang-format on
 {
-	HMODULE moduleAddress = LoadLibraryAOriginal(lpLibFileName);
+	HMODULE moduleAddress = _LoadLibraryA(lpLibFileName);
 
 	if (moduleAddress)
-	{
 		CallLoadLibraryACallbacks(lpLibFileName, moduleAddress);
-	}
 
 	return moduleAddress;
 }
 
-HMODULE LoadLibraryExWHook(LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags)
+// clang-format off
+AUTOHOOK_ABSOLUTEADDR(_LoadLibraryExW, LoadLibraryExW,
+HMODULE, WINAPI, (LPCWSTR lpLibFileName, HANDLE hFile, DWORD dwFlags))
+// clang-format on
 {
-	HMODULE moduleAddress = LoadLibraryExWOriginal(lpLibFileName, hFile, dwFlags);
+	HMODULE moduleAddress = _LoadLibraryExW(lpLibFileName, hFile, dwFlags);
 
 	if (moduleAddress)
-	{
 		CallLoadLibraryWCallbacks(lpLibFileName, moduleAddress);
-	}
 
 	return moduleAddress;
 }
 
-HMODULE LoadLibraryWHook(LPCWSTR lpLibFileName)
+// clang-format off
+AUTOHOOK_ABSOLUTEADDR(_LoadLibraryW, LoadLibraryW,
+HMODULE, WINAPI, (LPCWSTR lpLibFileName))
+// clang-format on
 {
-	HMODULE moduleAddress = LoadLibraryWOriginal(lpLibFileName);
+	HMODULE moduleAddress = _LoadLibraryW(lpLibFileName);
 
 	if (moduleAddress)
-	{
 		CallLoadLibraryWCallbacks(lpLibFileName, moduleAddress);
-	}
 
 	return moduleAddress;
 }
+
+void InstallInitialHooks()
+{
+	if (MH_Initialize() != MH_OK)
+		spdlog::error("MH_Initialize (minhook initialization) failed");
+
+	AUTOHOOK_DISPATCH()
+}