Move hostfxr-related code into a separate module

Author: Stat1cV01D

gm_dotnet_native/CMakeLists.txt

@@ -21,9 +21,19 @@ set(NET_CORE_VERSION "1.0.0" CACHE STRING "Version of bundled .NET Core Runtime"
 
 #Project name
 project(gm_dotnet_native)
-add_library(gm_dotnet_native SHARED src/gm_dotnet.cpp dotnethelper-src/cleanup_function_type.h utils/get_exe_path.cpp)
-add_library(dotnethelper SHARED dotnethelper-src/dotnethelper.cpp dotnethelper-src/cleanup_function_type.h
-		dotnethelper-src/LuaAPIExposure.h dotnethelper-src/LuaAPIExposure.cpp utils/get_exe_path.cpp)
+add_library(gm_dotnet_native SHARED
+	src/gm_dotnet.cpp
+	dotnethelper-src/cleanup_function_type.h
+	utils/path.cpp
+)
+add_library(dotnethelper SHARED
+	dotnethelper-src/dotnethelper.cpp
+	dotnethelper-src/cleanup_function_type.h
+	dotnethelper-src/LuaAPIExposure.h
+	dotnethelper-src/LuaAPIExposure.cpp
+	dotnethelper-src/hostfxr_interop.cpp
+	utils/path.cpp
+)
 #Set up external include libraries
 include_directories ("${EXTERNAL_INCLUDES_PATH}" "${CMAKE_CURRENT_SOURCE_DIR}")
 add_subdirectory ("${EXTERNAL_INCLUDES_PATH}/dynalo")

gm_dotnet_native/dotnethelper-src/dotnethelper.cpp

@@ -6,30 +6,22 @@
 #include <iostream>
 #include <string>
 #include <GarrysMod/Lua/LuaBase.h>
-#include <dynalo/dynalo.hpp>
-#include <netcore/coreclr_delegates.h>
 #include "LuaAPIExposure.h"
 #include "cleanup_function_type.h"
-#include "hostfxr_loader.h"
-#include "utils/get_exe_path.h"
+#include "hostfxr_interop.h"
+#include "utils/path.h"
 #ifdef WIN32
 #include <Windows.h>
 #else
 #include <cstring>
-#include <dlfcn.h>
-#include <unistd.h>
 #endif
 
 #ifdef WIN32
 #define DYNAMIC_EXPORT _declspec(dllexport)
-#define __T(x) L##x
 #else
 #define DYNAMIC_EXPORT __attribute__((visibility("default")))
-#define __T(x) x
 #endif
 
-#define _T(x) __T(x)
-
 typedef int (*managed_delegate_executor_fn)(lua_State* luaState);
 
 typedef cleanup_function_fn (*managed_main_fn)(GarrysMod::Lua::ILuaBase* lua,
@@ -46,9 +38,6 @@ std::ofstream error_log_file;
 managed_delegate_executor_fn managed_delegate_executor = nullptr;
 managed_main_fn managed_main = nullptr;
 
-const std::filesystem::path lua_bin_folder = _T("garrysmod/lua/bin");
-const dynalo::library hostfxr_library(lua_bin_folder / _T("dotnet/host/fxr") / NET_CORE_VERSION / dynalo::to_native_name("hostfxr"));
-
 void HOSTFXR_CALLTYPE dotnet_error_writer(const char_t* message)
 {
     error_log_file << message << std::endl;
@@ -130,72 +119,6 @@ void* params_to_managed_code[] = {
 };
 // clang-format on
 
-hostfxr_handle get_runtime_environment_handle(const hostfxr_functions& hostfxr)
-{
-    const auto dotnet_root_path = (std::filesystem::current_path() / lua_bin_folder / _T("dotnet")).make_preferred();
-    std::filesystem::path game_exe_path = utils::get_exe_path();
-
-    hostfxr_initialize_parameters dotnet_runtime_params;
-    dotnet_runtime_params.size = sizeof(hostfxr_initialize_parameters);
-    dotnet_runtime_params.host_path = game_exe_path.c_str();
-    dotnet_runtime_params.dotnet_root = dotnet_root_path.c_str();
-
-    const auto gmodnet_dll_relative_path = lua_bin_folder / _T("gmodnet/GmodNET.dll");
-    const char_t* dotnet_args[] = {_T("exec"), gmodnet_dll_relative_path.c_str()};
-
-    hostfxr_handle result = nullptr;
-    int error_code = hostfxr.initialize_for_dotnet_command_line(static_cast<int>(std::size(dotnet_args)),
-                                                                dotnet_args,
-                                                                &dotnet_runtime_params,
-                                                                &result);
-    if(error_code != 0)
-    {
-        throw std::runtime_error(std::string("Unable to initialize dotnet runtime. Error code: ") + std::to_string(error_code));
-    }
-    if(result == nullptr)
-    {
-        throw std::runtime_error("runtime_environment_handle is null");
-    }
-
-    return result;
-}
-
-get_function_pointer_fn get_dotnet_runtime_delegate(const hostfxr_functions& hostfxr, hostfxr_handle runtime_environment_handle)
-{
-    get_function_pointer_fn result = nullptr;
-    int error_code = hostfxr.get_runtime_delegate(runtime_environment_handle, hdt_get_function_pointer, reinterpret_cast<void**>(&result));
-    if(error_code != 0)
-    {
-        throw std::runtime_error(std::string("Unable to get delegate of dotnet runtime. Error code: ") + std::to_string(error_code));
-    }
-    if(result == nullptr)
-    {
-        throw std::runtime_error("get_function_pointer is null");
-    }
-
-    return result;
-}
-
-managed_main_fn load_gmodnet_main(get_function_pointer_fn get_function_pointer)
-{
-    managed_main_fn result = nullptr;
-    int error_code = get_function_pointer(_T("GmodNET.Startup, GmodNET"),
-                                          _T("Main"),
-                                          UNMANAGEDCALLERSONLY_METHOD,
-                                          nullptr,
-                                          nullptr,
-                                          reinterpret_cast<void**>(&result));
-    if(error_code != 0)
-    {
-        throw std::runtime_error(std::string("Unable to load managed entry point: Error code: ") + std::to_string(error_code));
-    }
-    if(result == nullptr)
-    {
-        throw std::runtime_error("Unable to load managed entry point: managed_main is null");
-    }
-    return result;
-}
-
 extern "C" DYNAMIC_EXPORT cleanup_function_fn InitNetRuntime(GarrysMod::Lua::ILuaBase* lua)
 {
     if(!error_log_file.is_open())
@@ -207,11 +130,9 @@ extern "C" DYNAMIC_EXPORT cleanup_function_fn InitNetRuntime(GarrysMod::Lua::ILu
     {
         try
         {
-            hostfxr_functions hostfxr(hostfxr_library);
+            hostfxr_interop hostfxr{};
             hostfxr.set_error_writer(dotnet_error_writer);
-            hostfxr_handle runtime_environment_handle = get_runtime_environment_handle(hostfxr);
-            get_function_pointer_fn get_function_pointer = get_dotnet_runtime_delegate(hostfxr, runtime_environment_handle);
-            managed_main = load_gmodnet_main(get_function_pointer);
+            managed_main = hostfxr.load_gmodnet_main<managed_main_fn>();
         }
         catch(const std::runtime_error& ex)
         {

gm_dotnet_native/dotnethelper-src/hostfxr_interop.cpp

@@ -0,0 +1,59 @@
+#include "hostfxr_interop.h"
+#include <type_traits>
+#include <dynalo/dynalo.hpp>
+#include "utils/path.h"
+
+#ifdef WIN32
+#define STRINGIZE _CRT_STRINGIZE
+#else
+#define STRINGIZE_(x) #x
+#define STRINGIZE(x) STRINGIZE_(x)
+#endif
+
+const std::filesystem::path dotnet_folder("dotnet");
+const std::filesystem::path gmodnet_dll_path("gmodnet/GmodNET.dll");
+const dynalo::library hostfxr_library(utils::path::lua_bin_folder / _T("dotnet/host/fxr") / NET_CORE_VERSION
+                                      / dynalo::to_native_name("hostfxr"));
+
+hostfxr_interop::hostfxr_interop()
+{
+#define LOAD_FN(x) x = hostfxr_library.get_function<std::remove_pointer_t<hostfxr_##x##_fn>>(STRINGIZE(hostfxr_##x))
+
+    LOAD_FN(initialize_for_dotnet_command_line);
+    LOAD_FN(get_runtime_delegate);
+    LOAD_FN(set_error_writer);
+
+#undef LOAD_FN
+}
+
+hostfxr_handle hostfxr_interop::init_runtime_for_gmodnet()
+{
+    const auto dotnet_root_path = (std::filesystem::current_path() / utils::path::lua_bin_folder / dotnet_folder).make_preferred();
+    std::filesystem::path game_exe_path = utils::path::get_exe();
+
+    hostfxr_initialize_parameters dotnet_runtime_params;
+    dotnet_runtime_params.size = sizeof(hostfxr_initialize_parameters);
+    dotnet_runtime_params.host_path = game_exe_path.c_str();
+    dotnet_runtime_params.dotnet_root = dotnet_root_path.c_str();
+
+    const auto gmodnet_dll_relative_path = utils::path::lua_bin_folder / gmodnet_dll_path;
+    const char_t* dotnet_args[] = {_T("exec"), gmodnet_dll_relative_path.c_str()};
+
+    return validate_call<hostfxr_handle>(
+        [&](auto* result) {
+            return initialize_for_dotnet_command_line(static_cast<int>(std::size(dotnet_args)), dotnet_args, &dotnet_runtime_params, result);
+        },
+        "hostfxr_handle",
+        "Unable to initialize dotnet runtime");
+}
+
+get_function_pointer_fn hostfxr_interop::managed_function_pointer_getter()
+{
+    hostfxr_handle runtime_environment_handle = init_runtime_for_gmodnet();
+    return validate_call<get_function_pointer_fn>(
+        [&](auto* result) {
+            return get_runtime_delegate(runtime_environment_handle, hdt_get_function_pointer, reinterpret_cast<void**>(result));
+        },
+        "get_function_pointer",
+        "Unable to get delegate of dotnet runtime");
+}

gm_dotnet_native/dotnethelper-src/hostfxr_interop.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <filesystem>
+#include <functional>
+#include <netcore/hostfxr.h>
+#include <netcore/coreclr_delegates.h>
+
+#ifdef WIN32
+#define __T(x) L##x
+#else
+#define __T(x) x
+#endif
+
+#define _T(x) __T(x)
+
+class hostfxr_interop
+{
+public:
+    explicit hostfxr_interop();
+
+    template<typename T>
+    T load_gmodnet_main();
+
+    hostfxr_set_error_writer_fn set_error_writer{};
+
+private:
+    template<typename T>
+    T validate_call(const std::function<int(T*)>& function_call, const std::string& result_name, const std::string& error_msg);
+    hostfxr_handle init_runtime_for_gmodnet();
+    get_function_pointer_fn managed_function_pointer_getter();
+
+private:
+    hostfxr_initialize_for_dotnet_command_line_fn initialize_for_dotnet_command_line{};
+    hostfxr_get_runtime_delegate_fn get_runtime_delegate{};
+};
+
+#include "hostfxr_interop_p.h"

gm_dotnet_native/dotnethelper-src/hostfxr_interop_p.h

@@ -0,0 +1,38 @@
+// hostfxr_interop's template method definitions
+
+template<typename T>
+T hostfxr_interop::validate_call(const std::function<int(T*)>& function_call, const std::string& result_name, const std::string& error_msg)
+{
+    static_assert(std::is_pointer_v<T>, "T must be a pointer type");
+
+    T result = nullptr;
+    int error_code = function_call(&result);
+    if(error_code != 0)
+    {
+        throw std::runtime_error(error_msg + " (error code: " + std::to_string(error_code) + ")");
+    }
+    if(result == nullptr)
+    {
+        throw std::runtime_error(result_name + " is null");
+    }
+
+    return result;
+}
+
+template<typename T>
+T hostfxr_interop::load_gmodnet_main()
+{
+    get_function_pointer_fn get_function_pointer = managed_function_pointer_getter();
+
+    return validate_call<T>(
+        [&](auto* result) {
+            return get_function_pointer(_T("GmodNET.Startup, GmodNET"),
+                                        _T("Main"),
+                                        UNMANAGEDCALLERSONLY_METHOD,
+                                        nullptr,
+                                        nullptr,
+                                        reinterpret_cast<void**>(result));
+        },
+        "managed_main",
+        "Unable to load managed entry point");
+}

gm_dotnet_native/dotnethelper-src/hostfxr_loader.h

@@ -7,7 +7,7 @@
 #include <execinfo.h>
 #include <unistd.h>
 #include <regex>
-#include "utils/get_exe_path.h"
+#include "utils/path.h"
 
 using namespace std;
 
@@ -57,7 +57,7 @@ extern "C" __attribute__((__visibility__("default"))) void install_sigsegv_handl
 {
     if(!WasHandlerSet)
     {
-        std::filesystem::path exe_path = utils::get_exe_path();
+        std::filesystem::path exe_path = utils::path::get_exe();
 
         regex file_matcher = regex(".*\\/gmod$");
         if(!regex_match(exe_path.native(), file_matcher))

gm_dotnet_native/linux-helper-src/segv_signal_handler.cpp

@@ -0,0 +1,24 @@
+#include "path.h"
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+#endif
+
+namespace utils::path
+{
+
+const std::filesystem::path lua_bin_folder = "garrysmod/lua/bin";
+
+std::filesystem::path get_exe()
+{
+    const int max_name_length = 301;
+    std::filesystem::path::string_type game_exe_path(max_name_length, '\0');
+#ifdef WIN32
+    GetModuleFileNameW(nullptr, game_exe_path.data(), static_cast<DWORD>(game_exe_path.size()) - 1);
+#else
+    int exe_path_length = readlink("/proc/self/exe", game_exe_path.data(), game_exe_path.size() - 1);
+#endif
+    return game_exe_path;
+}
+} //namespace utils

gm_dotnet_native/utils/path.cpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <filesystem>
+
+namespace utils::path
+{
+extern const std::filesystem::path lua_bin_folder;
+std::filesystem::path get_exe();
+}