Merge remote-tracking branch 'upstream/main' into tests-bass-experimental

Author: FirstLemon

.github/workflows/compile.yml

@@ -26,3 +26,5 @@ source/_versioninfo.h
 source/_prebuildtools/http/*.txt
 source/_prebuildtools/generated_summary.md
 source/modules/_modules.cpp
+
+projects/windows/vs2022/

.gitignore

@@ -64,11 +64,11 @@ namespace Util
 class CExampleModule : public IModule
 {
 public:
-	virtual void LuaInit(GarrysMod::Lua::ILuaInterface* pLua, bool bServerInit) override;
-	virtual void LuaShutdown(GarrysMod::Lua::ILuaInterface* pLua) override;
-	virtual const char* Name() { return "example"; };
-	virtual int Compatibility() { return LINUX32 | LINUX64 | WINDOWS32 | WINDOWS64; };
-	virtual bool SupportsMultipleLuaStates() { return true; }; // This currently is unused
+	void LuaInit(GarrysMod::Lua::ILuaInterface* pLua, bool bServerInit) override;
+	void LuaShutdown(GarrysMod::Lua::ILuaInterface* pLua) override;
+	const char* Name() override { return "example"; };
+	int Compatibility() override { return LINUX32 | LINUX64 | WINDOWS32 | WINDOWS64; };
+	bool SupportsMultipleLuaStates() override { return true; }; // This currently is unused
 };
 
 LUA_FUNCTION_STATIC(example_hello)

README.md

@@ -3,6 +3,12 @@
 #include "interface.h"
 #include "Bootil/Bootil.h"
 
+#ifdef PLATFORM_64BITS
+#define HOLYLIB_CONFIG_PATH "garrysmod/holylib/cfg/x64/"
+#else
+#define HOLYLIB_CONFIG_PATH "garrysmod/holylib/cfg/x86/"
+#endif
+
 /*
 	This is the exposed config system used by holylib for it's config files.
 */
@@ -18,6 +24,8 @@ enum ConfigState
 abstract_class IConfig
 {
 public:
+	virtual ~IConfig() {};
+
 	// Returns true if the config was just created. Add your default values and then save it!
 	virtual ConfigState GetState() = 0;
 

development/module/premake5

@@ -68,6 +68,22 @@ class IHolyUtil
 	// A bind to CM_Vis allowing you to load the PVS/PAS into the given cluster.
 	// type = DVIS_PAS(1) or DVIS_PVS(0)
 	virtual bool CM_Vis(byte* cluster, int clusterSize, int cluserID, int type) = 0;
+
+	// Blocks the creation of the given gameevent.
+	// Does nothing if the the gameevent is already blocked.
+	virtual void BlockGameEvent(const char* pName) = 0;
+
+	// Unblocks the creation of the given gameevent.
+	// Does nothing if the the gameevent is not blocked.
+	virtual void UnblockGameEvent(const char* pName) = 0;
+
+	// tries to find a SendProp with the given name
+	// and if found it will return the offset stored in the sendprop.
+	// Returns -1 on failure
+	virtual int FindOffsetForNetworkVar(const char* pDTName, const char* pVarName) = 0;
+
+	// Returns a pointer to the given offset for the base, do the casting yourself.
+	virtual void* GoToNetworkVarOffset(void* pBase, int nOffset) = 0;
 };
 
 // Should we make this also a interface? :^ (Ye :3)

example-module-dll/source/example.cpp

@@ -246,6 +246,15 @@ class IModuleManager
 	// This usually means we were loaded by require("holylib")
 	virtual bool IsMarkedAsBinaryModule() = 0;
 
+	// Tells modules that they can expose / use unsafe code
+	// This allows them to provide an unrestricted API
+	// Though of course people should only use it if they know their code isn't potentially malicious.
+	// (or they may have outside addons/sources that could become malicious)
+	virtual void EnableUnsafeCode() = 0;
+
+	// Returns true if unsafe code is allowed
+	virtual bool IsUnsafeCodeEnabled() = 0;
+
 	// This function is sets the internal variables.
 	virtual void Setup(CreateInterfaceFn appfn, CreateInterfaceFn gamefn) = 0;
 

example-module-dll/source/public/iconfigsystem.h

@@ -0,0 +1,100 @@
+return {
+    groupName = "HolyLib manages to properly Get HolyLib Referenced UserData to Lua",
+    cases = {
+        {
+            name = "Is _HOLYLIB_CORE.GetReferencedTestUserData function existent",
+            func = function()
+                expect( _HOLYLIB_CORE.GetReferencedTestUserData ).to.beA( "function" )
+            end
+        },
+        {
+            name = "Properly got the valid pointer to our userdata",
+            func = function()
+                local userdata = _HOLYLIB_CORE.PushReferencedTestUserData()
+                expect( userdata ).to.beA( "_HOLYLIB_CORE_TEST_REFERENCED" )
+
+                -- If we got a garbage pointer, this will return false or crash.
+                expect( _HOLYLIB_CORE.GetReferencedTestUserData(userdata) ).to.beTrue()
+            end
+        },
+        {
+            name = "__newindex and __index functions properly work on userdata",
+            func = function()
+                local userdata = _HOLYLIB_CORE.PushReferencedTestUserData()
+                expect( userdata ).to.beA( "_HOLYLIB_CORE_TEST_REFERENCED" )
+
+                userdata.example = "Hello World"
+
+                expect( userdata.example ).to.equal( "Hello World" )
+            end
+        },
+        {
+            name = "Performance",
+            func = function()
+                local userdata = _HOLYLIB_CORE.PushReferencedTestUserData()
+                HolyLib_RunPerformanceTest("_HOLYLIB_CORE.GetReferencedTestUserData", _HOLYLIB_CORE.RawReferencedGetTestUserData, userdata)
+
+                HolyLib_RunPerformanceTest("_HOLYLIB_CORE.__newindex", function(userdata) userdata.example = "Hello World" end, userdata)
+                HolyLib_RunPerformanceTest("_HOLYLIB_CORE.__index", function(userdata) return userdata.example end, userdata)
+            end
+        },
+        {
+            name = "LuaJIT traces do not create a crash",
+            async = true,
+            timeout = 5,
+            func = function()
+                --[[
+                    Very specific crash caused by LuaJIT generating a GCtrace which then for very magical reasons can lead to memory corruption of userdata
+                ]]
+
+                function generate_trace()
+                    jit.opt.start("hotloop=1", "hotexit=1")
+                    jit.flush()
+
+                    --[[jit.attach(function(what, traceno, func, pc, exitno)
+                        if exitno ~= nil then what = "abort" end
+
+                        local src = "<unknown>"
+                        if type(func) == "function" or type(func) == "proto" then
+                            local info = jit.util.funcinfo(func)
+                            if info then
+                                src = string.format("%s:%d", info.source or "C", info.linedefined or 0)
+                            end
+                        elseif func ~= nil then
+                            src = tostring(func)
+                        end
+
+                        print(string.format("[TRACE] %-6s %s %-35s pc=%s exit=%s",
+                            tostring(what),
+                            tostring(traceno or "?"),
+                            tostring(src),
+                            tostring(pc or "-"),
+                            tostring(exitno or "-")
+                        ))
+                    end, "trace")]]
+
+                    local function trace_userdata(u)
+                        return u.test
+                    end
+
+                    local userData = _HOLYLIB_CORE.PushReferencedTestUserData()
+                    for n = 1, 1e4 do -- Generate those sweet GCtrace
+                        trace_userdata(userData)
+                    end
+                end
+
+                generate_trace()
+
+                timer.Simple(1, function()
+                    collectgarbage("collect")
+
+                    timer.Simple(1, function()
+                        generate_trace() -- If this crashes, we got a problem...
+
+                        done()
+                    end)
+                end)
+            end
+        },
+    }
+}

example-module-dll/source/public/iholyutil.h

@@ -32,6 +32,55 @@ return {
                 expect( actualTable ).to.deepEqual( expectedTable )
             end
         },
+        { -- This the second reported crash from: https://github.com/RaphaelIT7/gmod-holylib/issues/101
+            name = "Returns a proper result",
+            when = HolyLib_IsModuleEnabled("util"),
+            func = function()
+                local expectedTable = {
+                    {
+                        a = 1,
+                        b = 2,
+                    }
+                }
+
+                -- Input forces it to enter IsArray, which then recursively calls to IsObject internally as this focus on testing if the stack is properly taken account of
+                -- Formerly, this was screwed up as it handled pushing values wrong pushing more than one value onto the stack resulting in a stack leak and other weird behavior.
+                local actualTable = util.FancyJSONToTable( '[{"a":1,"b":2}]' )
+
+                expect( actualTable ).to.deepEqual( expectedTable )
+            end
+        },
+        { -- This the third reported issue from (it just never stops :sob:): https://github.com/RaphaelIT7/gmod-holylib/issues/101
+            name = "Returns a proper result",
+            when = HolyLib_IsModuleEnabled("util"),
+            func = function()
+                local expectedTable = {
+                	name = "[Important: HolyLibIsGoated]",
+                    pos = Vector(4, 2, 0)
+                }
+
+                -- Input uses [ ] though does not focus on being a vector, instead its just a normal string using it
+                -- This focuses on the internal validation ensuring no garbage vectors are returned (which they previously were)
+                local actualTable = util.FancyJSONToTable( '{"pos": "[4 2 0]", "name": "[Important: HolyLibIsGoated]"}' )
+
+                expect( actualTable ).to.deepEqual( expectedTable )
+            end
+        },
+        {
+            name = "Returns a proper result",
+            when = HolyLib_IsModuleEnabled("util"),
+            func = function()
+                local expectedTable = {
+                    [1] = "a",
+                    [2] = "b",
+                    ["0YHolyLibIsS0C00L"] = "c",
+                }
+
+                local actualTable = util.FancyJSONToTable( '{"1":"a","2":"b","0YHolyLibIsS0C00L":"c"}' )
+
+                expect( actualTable ).to.deepEqual( expectedTable )
+            end
+        },
         {
             name = "Performance",
             when = HolyLib_IsModuleEnabled("util"),