Public-Mirror/LunaHook-mirror
1
0
Fork 0
mirror of https://github.com/HIllya51/LunaHook.git synced 2024-11-27 07:44:02 +08:00
Code Issues Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
恍兮惚兮 2024-05-14 20:37:48 +08:00
parent d34ed3473d
commit 1c60d6c4cc
11 changed files with 674 additions and 1028 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -62,7 +62,7 @@ include(generate_product_version)
set(VERSION_MAJOR 3) set(VERSION_MAJOR 3)
set(VERSION_MINOR 2) set(VERSION_MINOR 2)
set(VERSION_PATCH 2) set(VERSION_PATCH 3)
set(VERSION_REVISION 0) set(VERSION_REVISION 0)
if(BUILD_CORE) if(BUILD_CORE)

2
LunaHook/engines/CMakeLists.txt
View File

@ -1,4 +1,4 @@
add_library(commonengine mono/impl_mono.cpp mono/impl_il2cpp.cpp ppsspp/ppsspp.cpp mages/mages.cpp v8/v8.cpp python/python2.cpp python/python3.cpp python/python.cpp pchooks/pchooks.cpp) add_library(commonengine mono/impl_mono.cpp mono/monoil2cpp.cpp mono/impl_il2cpp.cpp ppsspp/ppsspp.cpp mages/mages.cpp v8/v8.cpp python/python2.cpp python/python3.cpp python/python.cpp pchooks/pchooks.cpp)
target_precompile_headers(commonengine REUSE_FROM pchhook) target_precompile_headers(commonengine REUSE_FROM pchhook)

197
LunaHook/engines/mono/def_il2cpp.hpp
View File

@ -483,96 +483,6 @@ typedef struct MulticastDelegate : Il2CppDelegate {
Il2CppArraySize* delegates; Il2CppArraySize* delegates;
} MulticastDelegate; } MulticastDelegate;
// function types
typedef Il2CppString* (*il2cpp_string_new_utf16_t)(const wchar_t* str, unsigned int len);
typedef Il2CppString* (*il2cpp_string_new_t)(const char* str);
typedef void* (*il2cpp_domain_get_t)();
typedef void** (*il2cpp_domain_get_assemblies_t)(void* domain, std::size_t* size);
typedef void* (*il2cpp_domain_assembly_open_t)(void* domain, const char* name);
typedef void* (*il2cpp_assembly_get_image_t)(void* assembly);
typedef Il2CppClass* (*il2cpp_class_from_name_t)(void* image, const char* namespaze, const char* name);
typedef MethodInfo* (*il2cpp_class_get_methods_t)(Il2CppClass* klass, void** iter);
typedef MethodInfo* (*il2cpp_class_get_method_from_name_t)(Il2CppClass* klass, const char* name, int argsCount);
typedef MethodInfo* (*il2cpp_method_get_from_reflection_t)(Il2CppObject* ref);
typedef const Il2CppType* (*il2cpp_method_get_param_t)(const MethodInfo* method, uint32_t index);
typedef Il2CppObject* (*il2cpp_object_new_t)(Il2CppClass* klass);
typedef void (*il2cpp_add_internal_call_t)(const char* name, uintptr_t pointer);
typedef void* (*il2cpp_resolve_icall_t)(const char* name);
typedef Il2CppArraySize* (*il2cpp_array_new_t)(Il2CppClass* klass, uintptr_t count);
typedef void* (*il2cpp_thread_attach_t)(void* domain);
typedef void (*il2cpp_thread_detach_t)(void* thread);
typedef const Il2CppType* (*il2cpp_class_get_type_t)(Il2CppClass* klass);
typedef uint32_t(*il2cpp_class_get_type_token_t)(Il2CppClass* klass);
typedef FieldInfo* (*il2cpp_class_get_field_from_name_t)(Il2CppClass* klass, const char* name);
typedef void (*il2cpp_field_get_value_t)(Il2CppObject* obj, FieldInfo* field, void* value);
typedef void (*il2cpp_field_set_value_t)(Il2CppObject* obj, FieldInfo* field, void* value);
typedef void (*il2cpp_field_static_get_value_t)(FieldInfo* field, void* value);
typedef void (*il2cpp_field_static_set_value_t)(FieldInfo* field, void* value);
typedef const Il2CppType* (*il2cpp_field_get_type_t)(FieldInfo* field);
typedef Il2CppObject* (*il2cpp_type_get_object_t)(const Il2CppType* type);
typedef const char* (*il2cpp_image_get_name_t)(void* image);
typedef size_t(*il2cpp_image_get_class_count_t)(void* image);
typedef const Il2CppClass* (*il2cpp_image_get_class_t)(void* image, size_t index);
typedef bool (*il2cpp_type_is_byref_t)(const Il2CppType* type);
typedef uint32_t(*il2cpp_method_get_flags_t)(const MethodInfo* mehod, uint32_t* iflags);
typedef const Il2CppType* (*il2cpp_method_get_return_type_t)(const MethodInfo* method);
typedef Il2CppClass* (*il2cpp_class_from_type_t)(const Il2CppType* type);
typedef const char* (*il2cpp_class_get_name_t)(Il2CppClass* klass);
typedef const PropertyInfo* (*il2cpp_class_get_properties_t)(Il2CppClass* klass, void** iter);
typedef bool (*il2cpp_class_is_enum_t)(const Il2CppClass* klass);
typedef FieldInfo* (*il2cpp_class_get_fields_t)(Il2CppClass* klass, void** iter);
typedef const char* (*il2cpp_method_get_name_t)(const MethodInfo* method);
typedef uint32_t(*il2cpp_method_get_param_count_t)(const MethodInfo* method);
typedef const char* (*il2cpp_method_get_param_name_t)(const MethodInfo* method, uint32_t index);
typedef Il2CppClass* (*il2cpp_class_get_parent_t)(Il2CppClass* klass);
typedef Il2CppClass* (*il2cpp_class_get_interfaces_t)(Il2CppClass* klass, void** iter);
typedef const char* (*il2cpp_class_get_namespace_t)(Il2CppClass* klass);
typedef void* (*il2cpp_class_get_image_t)(Il2CppClass* klass);
typedef int (*il2cpp_class_get_flags_t)(const Il2CppClass* klass);
typedef bool (*il2cpp_class_is_valuetype_t)(const Il2CppClass* klass);
typedef uint32_t(*il2cpp_property_get_flags_t) (PropertyInfo* prop);
typedef const MethodInfo* (*il2cpp_property_get_get_method_t) (const PropertyInfo* prop);
typedef const MethodInfo* (*il2cpp_property_get_set_method_t) (const PropertyInfo* prop);
typedef const char* (*il2cpp_property_get_name_t) (const PropertyInfo* prop);
typedef Il2CppClass* (*il2cpp_property_get_parent_t) (const PropertyInfo* prop);
typedef int (*il2cpp_field_get_flags_t)(FieldInfo* field);
typedef const char* (*il2cpp_field_get_name_t)(FieldInfo* field);
typedef Il2CppClass* (*il2cpp_field_get_parent_t)(FieldInfo* field);
typedef size_t (*il2cpp_field_get_offset_t)(FieldInfo* field);
typedef const PropertyInfo* (*il2cpp_class_get_property_from_name_t)(Il2CppClass* klass, const char* name);
typedef void (*il2cpp_runtime_object_init_t)(Il2CppObject* obj);
typedef Il2CppObject* (*il2cpp_value_box_t)(Il2CppClass* klass, void* data);
typedef void* (*il2cpp_object_unbox_t)(Il2CppObject* obj);
char* il2cpp_array_addr_with_size(void* arr, int32_t size, uintptr_t idx);
// array macro
#define il2cpp_array_addr(array, type, index) ((type*)(void*) il2cpp_array_addr_with_size (array, sizeof (type), index))
#define il2cpp_array_setref(array, index, value) \
do { \
void* *__p = (void* *) il2cpp_array_addr ((array), void*, (index)); \
*__p = (value); \
} while (0)
namespace il2cpp_symbols
{
inline void* il2cpp_domain = nullptr;
void init(HMODULE game_module);
uintptr_t get_method_pointer(const char* assemblyName, const char* namespaze,
const char* klassName, const char* name, int argsCount,bool strict);
Il2CppClass* get_class(const char* assemblyName, const char* namespaze, const char* klassName);
MethodInfo* get_method(const char* assemblyName, const char* namespaze,
const char* klassName, const char* name, int argsCount);
Il2CppClass* find_class(const char* assemblyName, const char* namespaze, std::function<bool(Il2CppClass*)> predict);
uintptr_t find_method(const char* assemblyName, const char* namespaze,
const char* klassName, std::function<bool(const MethodInfo*)> predict);
}
// UnityEngine.Quaternion // UnityEngine.Quaternion
struct Quaternion_t struct Quaternion_t
@ -612,36 +522,81 @@ struct Il2CppReflectionType
}; };
// function types inline void** (*il2cpp_domain_get_assemblies)(void* domain, std::size_t* size);
typedef Il2CppString* (*il2cpp_string_new_utf16_t)(const wchar_t* str, unsigned int len); inline Il2CppClass* (*il2cpp_class_from_name)(void* image, const char* namespaze, const char* name);
typedef Il2CppString* (*il2cpp_string_new_t)(const char* str); inline MethodInfo* (*il2cpp_class_get_methods)(Il2CppClass* klass, void** iter);
typedef void* (*il2cpp_domain_get_t)(); inline MethodInfo* (*il2cpp_class_get_method_from_name)(Il2CppClass* klass, const char* name, int argsCount);
typedef void* (*il2cpp_domain_assembly_open_t)(void* domain, const char* name); inline MethodInfo* (*il2cpp_method_get_from_reflection)(Il2CppObject* ref);
typedef void* (*il2cpp_assembly_get_image_t)(void* assembly); inline const Il2CppType* (*il2cpp_method_get_param)(const MethodInfo* method, uint32_t index);
inline Il2CppObject* (*il2cpp_object_new)(Il2CppClass* klass);
inline void (*il2cpp_add_internal_call)(const char* name, uintptr_t pointer);
inline Il2CppArraySize* (*il2cpp_array_new)(Il2CppClass* klass, uintptr_t count);
inline const Il2CppType* (*il2cpp_class_get_type)(Il2CppClass* klass);
inline uint32_t(*il2cpp_class_get_type_token)(Il2CppClass* klass);
inline FieldInfo* (*il2cpp_class_get_field_from_name)(Il2CppClass* klass, const char* name);
inline void (*il2cpp_field_get_value)(Il2CppObject* obj, FieldInfo* field, void* value);
inline void (*il2cpp_field_set_value)(Il2CppObject* obj, FieldInfo* field, void* value);
inline void (*il2cpp_field_static_get_value)(FieldInfo* field, void* value);
inline void (*il2cpp_field_static_set_value)(FieldInfo* field, void* value);
inline const Il2CppType* (*il2cpp_field_get_type)(FieldInfo* field);
inline Il2CppObject* (*il2cpp_type_get_object)(const Il2CppType* type);
inline const char* (*il2cpp_image_get_name)(void* image);
inline size_t(*il2cpp_image_get_class_count)(void* image);
inline const Il2CppClass* (*il2cpp_image_get_class)(void* image, size_t index);
inline bool (*il2cpp_type_is_byref)(const Il2CppType* type);
inline uint32_t(*il2cpp_method_get_flags)(const MethodInfo* mehod, uint32_t* iflags);
inline const Il2CppType* (*il2cpp_method_get_return_type)(const MethodInfo* method);
inline Il2CppClass* (*il2cpp_class_from_type)(const Il2CppType* type);
inline const char* (*il2cpp_class_get_name)(Il2CppClass* klass);
inline const PropertyInfo* (*il2cpp_class_get_properties)(Il2CppClass* klass, void** iter);
inline bool (*il2cpp_class_is_enum)(const Il2CppClass* klass);
inline FieldInfo* (*il2cpp_class_get_fields)(Il2CppClass* klass, void** iter);
inline const char* (*il2cpp_method_get_name)(const MethodInfo* method);
inline uint32_t(*il2cpp_method_get_param_count)(const MethodInfo* method);
inline const char* (*il2cpp_method_get_param_name)(const MethodInfo* method, uint32_t index);
inline Il2CppClass* (*il2cpp_class_get_parent)(Il2CppClass* klass);
inline Il2CppClass* (*il2cpp_class_get_interfaces)(Il2CppClass* klass, void** iter);
inline const char* (*il2cpp_class_get_namespace)(Il2CppClass* klass);
inline void* (*il2cpp_class_get_image)(Il2CppClass* klass);
inline int (*il2cpp_class_get_flags)(const Il2CppClass* klass);
inline bool (*il2cpp_class_is_valuetype)(const Il2CppClass* klass);
inline uint32_t(*il2cpp_property_get_flags) (PropertyInfo* prop);
inline const MethodInfo* (*il2cpp_property_get_get_method) (const PropertyInfo* prop);
inline const MethodInfo* (*il2cpp_property_get_set_method) (const PropertyInfo* prop);
inline const char* (*il2cpp_property_get_name) (const PropertyInfo* prop);
inline Il2CppClass* (*il2cpp_property_get_parent) (const PropertyInfo* prop);
inline int (*il2cpp_field_get_flags)(FieldInfo* field);
inline const char* (*il2cpp_field_get_name)(FieldInfo* field);
inline Il2CppClass* (*il2cpp_field_get_parent)(FieldInfo* field);
inline size_t (*il2cpp_field_get_offset)(FieldInfo* field);
inline const PropertyInfo* (*il2cpp_class_get_property_from_name)(Il2CppClass* klass, const char* name);
inline void (*il2cpp_runtime_object_init)(Il2CppObject* obj);
inline Il2CppObject* (*il2cpp_value_box)(Il2CppClass* klass, void* data);
inline void* (*il2cpp_object_unbox)(Il2CppObject* obj);
inline Il2CppString* (*il2cpp_string_new_utf16)(const wchar_t* str, unsigned int len);
inline Il2CppString* (*il2cpp_string_new)(const char* str);
inline void* (*il2cpp_domain_get)();
inline void* (*il2cpp_domain_assembly_open)(void* domain, const char* name);
inline void* (*il2cpp_assembly_get_image)(void* assembly);
inline void* (*il2cpp_resolve_icall)(const char* name);
inline void* (*il2cpp_thread_attach)(void* domain);
inline void (*il2cpp_thread_detach)(void* thread);
inline bool (*il2cpp_class_is_assignable_from)(void* klass, void* oklass);
inline void (*il2cpp_class_for_each)(void(*klassReportFunc)(Il2CppClass* klass, void* userData), void* userData);
inline void* (*il2cpp_class_get_nested_types)(void* klass, void** iter);
inline uint32_t(*il2cpp_gchandle_new)(void* obj, bool pinned);
inline void (*il2cpp_gchandle_free)(uint32_t gchandle);
inline void* (*il2cpp_gchandle_get_target)(uint32_t gchandle);
inline void (*il2cpp_runtime_class_init)(void* klass);
inline void* (*il2cpp_runtime_invoke)(MethodInfo* method, void* obj, void** params, Il2CppObject** exc);
inline Il2CppChar* (*il2cpp_string_chars)(Il2CppString* str);
inline int (*il2cpp_string_length)(Il2CppString* str);
namespace il2cppfunctions{
void init(HMODULE dll);
uintptr_t get_method_pointer(const char* assemblyName, const char* namespaze,
typedef void* (*il2cpp_resolve_icall_t)(const char* name); const char* klassName, const char* name, int argsCount,bool strict);
std::optional<std::wstring_view> get_string(void*);
typedef void* (*il2cpp_thread_attach_t)(void* domain); void* create_string(std::wstring_view ws);
typedef void (*il2cpp_thread_detach_t)(void* thread); }
typedef bool (*il2cpp_class_is_assignable_from_t)(void* klass, void* oklass);
typedef void (*il2cpp_class_for_each_t)(void(*klassReportFunc)(Il2CppClass* klass, void* userData), void* userData);
typedef void* (*il2cpp_class_get_nested_types_t)(void* klass, void** iter);
typedef uint32_t(*il2cpp_gchandle_new_t)(void* obj, bool pinned);
typedef void (*il2cpp_gchandle_free_t)(uint32_t gchandle);
typedef void* (*il2cpp_gchandle_get_target_t)(uint32_t gchandle);
typedef void (*il2cpp_runtime_class_init_t)(void* klass);
typedef void* (*il2cpp_runtime_invoke_t)(MethodInfo* method, void* obj, void** params, Il2CppObject** exc);
char* il2cpp_array_addr_with_size(void* arr, int32_t size, uintptr_t idx);
// array macro
#define il2cpp_array_addr(array, type, index) ((type*)(void*) il2cpp_array_addr_with_size (array, sizeof (type), index))

476
LunaHook/engines/mono/def_mono.hpp
View File

@ -28,7 +28,7 @@ struct MonoReflectionAssembly;
struct MonoReflectionMethod; struct MonoReflectionMethod;
struct MonoAppDomain; struct MonoAppDomain;
struct MonoCustomAttrInfo; struct MonoCustomAttrInfo;
struct MonoTableInfo;
struct MonoReflectionType { UInt32 offset[2]; MonoType* type;}; struct MonoReflectionType { UInt32 offset[2]; MonoType* type;};
typedef void* gconstpointer; typedef void* gconstpointer;
@ -171,236 +171,246 @@ typedef void (*MonoProfileExceptionClauseFunc) (MonoProfiler *prof, MonoMethod *
typedef void (*MonoProfileThreadFunc) (MonoProfiler *prof, uint32_t tid); typedef void (*MonoProfileThreadFunc) (MonoProfiler *prof, uint32_t tid);
typedef void (*mono_thread_suspend_all_other_threads_t)(); inline void (*mono_thread_suspend_all_other_threads)();
typedef void (*mono_thread_pool_cleanup_t)(); inline void (*mono_thread_pool_cleanup)();
typedef void (*mono_threads_set_shutting_down_t)(); inline void (*mono_threads_set_shutting_down)();
typedef void (*mono_runtime_set_shutting_down_t)(); inline void (*mono_runtime_set_shutting_down)();
typedef gboolean (*mono_domain_finalize_t)(MonoDomain *domain, int timeout); inline gboolean (*mono_domain_finalize)(MonoDomain *domain, int timeout);
typedef void (*mono_runtime_cleanup_t)(MonoDomain *domain); inline void (*mono_runtime_cleanup)(MonoDomain *domain);
typedef MonoMethodDesc *(*mono_method_desc_new_t)(const char *name, gboolean include_namespace); inline MonoMethodDesc *(*mono_method_desc_new)(const char *name, gboolean include_namespace);
typedef MonoMethod *(*mono_method_desc_search_in_image_t)(MonoMethodDesc *desc, MonoImage *image); inline MonoMethod *(*mono_method_desc_search_in_image)(MonoMethodDesc *desc, MonoImage *image);
typedef void (*mono_verifier_set_mode_t)(MiniVerifierMode m); inline void (*mono_verifier_set_mode)(MiniVerifierMode m);
typedef void (*mono_security_set_mode_t)(MonoSecurityMode m); inline void (*mono_security_set_mode)(MonoSecurityMode m);
typedef void (*mono_add_internal_call_t)(const char *name, gconstpointer method); inline void (*mono_add_internal_call)(const char *name, gconstpointer method);
typedef void (*mono_jit_cleanup_t)(MonoDomain *domain); inline void (*mono_jit_cleanup)(MonoDomain *domain);
typedef MonoDomain *(*mono_jit_init_t)(const char *file); inline MonoDomain *(*mono_jit_init)(const char *file);
typedef MonoDomain *(*mono_jit_init_version_t)(const char *file, const char *runtime_version); inline MonoDomain *(*mono_jit_init_version)(const char *file, const char *runtime_version);
typedef int (*mono_jit_exec_t)(MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]); inline int (*mono_jit_exec)(MonoDomain *domain, MonoAssembly *assembly, int argc, char *argv[]);
typedef MonoClass *(*mono_class_from_name_t)(MonoImage *image, const char *name_space, const char *name); inline MonoClass *(*mono_class_from_name)(MonoImage *image, const char *name_space, const char *name);
typedef MonoAssembly *(*mono_domain_assembly_open_t)(MonoDomain *domain, const char *name); inline MonoAssembly *(*mono_domain_assembly_open)(MonoDomain *domain, const char *name);
typedef MonoDomain *(*mono_domain_create_appdomain_t)(const char *domainname, const char *configfile); inline MonoDomain *(*mono_domain_create_appdomain)(const char *domainname, const char *configfile);
typedef void (*mono_domain_unload_t)(MonoDomain *domain); inline void (*mono_domain_unload)(MonoDomain *domain);
typedef MonoObject *(*mono_object_new_t)(MonoDomain *domain, MonoClass *klass); inline MonoObject *(*mono_object_new)(MonoDomain *domain, MonoClass *klass);
typedef void (*mono_runtime_object_init_t)(MonoObject *this_obj); inline void (*mono_runtime_object_init)(MonoObject *this_obj);
typedef MonoObject *(*mono_runtime_invoke_t)(MonoMethod *method, void *obj, void **params, MonoObject **exc); inline MonoObject *(*mono_runtime_invoke)(MonoMethod *method, void *obj, void **params, MonoObject **exc);
typedef void (*mono_field_set_value_t)(MonoObject *obj, MonoClassField *field, void *value); inline void (*mono_field_set_value)(MonoObject *obj, MonoClassField *field, void *value);
typedef void (*mono_field_get_value_t)(MonoObject *obj, MonoClassField *field, void *value); inline void (*mono_field_get_value)(MonoObject *obj, MonoClassField *field, void *value);
typedef int (*mono_field_get_offset_t)(MonoClassField *field); inline int (*mono_field_get_offset)(MonoClassField *field);
typedef MonoClassField *(*mono_class_get_fields_t)(MonoClass *klass, gpointer *iter); inline MonoClassField *(*mono_class_get_fields)(MonoClass *klass, gpointer *iter);
typedef MonoMethod *(*mono_class_get_methods_t)(MonoClass *klass, gpointer *iter); inline MonoMethod *(*mono_class_get_methods)(MonoClass *klass, gpointer *iter);
typedef MonoDomain *(*mono_domain_get_t)(); inline MonoDomain *(*mono_domain_get)();
typedef MonoDomain *(*mono_get_root_domain_t)(); inline MonoDomain *(*mono_get_root_domain)();
typedef gint32 (*mono_domain_get_id_t)(MonoDomain *domain); inline gint32 (*mono_domain_get_id)(MonoDomain *domain);
typedef void (*mono_assembly_foreach_t)(GFunc func, gpointer user_data); inline void (*mono_assembly_foreach)(GFunc func, gpointer user_data);
typedef void (*mono_image_close_t)(MonoImage *image); inline void (*mono_image_close)(MonoImage *image);
typedef void (*mono_unity_socket_security_enabled_set_t)(gboolean b); inline void (*mono_unity_socket_security_enabled_set)(gboolean b);
typedef const char *(*mono_image_get_name_t)(MonoImage *image); inline const char *(*mono_image_get_name)(MonoImage *image);
typedef MonoClass *(*mono_get_object_class_t)(); inline MonoClass *(*mono_get_object_class)();
typedef void (*mono_set_commandline_arguments_t)(int i, const char *argv[], const char *s); inline void (*mono_set_commandline_arguments)(int i, const char *argv[], const char *s);
typedef const char *(*mono_field_get_name_t)(MonoClassField *field); inline const char *(*mono_field_get_name)(MonoClassField *field);
typedef MonoType *(*mono_field_get_type_t)(MonoClassField *field); inline MonoType *(*mono_field_get_type)(MonoClassField *field);
typedef int (*mono_type_get_type_t)(MonoType *type); inline int (*mono_type_get_type)(MonoType *type);
typedef const char *(*mono_method_get_name_t)(MonoMethod *method); inline const char *(*mono_method_get_name)(MonoMethod *method);
typedef MonoImage *(*mono_assembly_get_image_t)(MonoAssembly *assembly); inline MonoImage *(*mono_assembly_get_image)(MonoAssembly *assembly);
typedef MonoClass *(*mono_method_get_class_t)(MonoMethod *method); inline MonoClass *(*mono_method_get_class)(MonoMethod *method);
typedef MonoClass *(*mono_object_get_class_t)(MonoObject *obj); inline MonoClass *(*mono_object_get_class)(MonoObject *obj);
typedef gboolean (*mono_class_is_valuetype_t)(MonoClass *klass); inline gboolean (*mono_class_is_valuetype)(MonoClass *klass);
typedef guint32 (*mono_signature_get_param_count_t)(MonoMethodSignature *sig); inline guint32 (*mono_signature_get_param_count)(MonoMethodSignature *sig);
typedef char *(*mono_string_to_utf8_t)(MonoString *string_obj); inline char *(*mono_string_to_utf8)(MonoString *string_obj);
typedef MonoString *(*mono_string_new_wrapper_t)(const char *text); inline MonoString *(*mono_string_new_wrapper)(const char *text);
typedef MonoClass *(*mono_class_get_parent_t)(MonoClass *klass); inline MonoClass *(*mono_class_get_parent)(MonoClass *klass);
typedef const char *(*mono_class_get_namespace_t)(MonoClass *klass); inline const char *(*mono_class_get_namespace)(MonoClass *klass);
typedef gboolean (*mono_class_is_subclass_of_t)(MonoClass *klass, MonoClass *klassc, gboolean check_interfaces); inline gboolean (*mono_class_is_subclass_of)(MonoClass *klass, MonoClass *klassc, gboolean check_interfaces);
typedef const char *(*mono_class_get_name_t)(MonoClass *klass); inline const char *(*mono_class_get_name)(MonoClass *klass);
typedef char *(*mono_type_get_name_t)(MonoType *type); inline char *(*mono_type_get_name)(MonoType *type);
typedef MonoClass *(*mono_type_get_class_t)(MonoType *type); inline MonoClass *(*mono_type_get_class)(MonoType *type);
typedef MonoException *(*mono_exception_from_name_msg_t)(MonoImage *image, const char *name_space, const char *name, const char *msg); inline MonoException *(*mono_exception_from_name_msg)(MonoImage *image, const char *name_space, const char *name, const char *msg);
typedef void (*mono_raise_exception_t)(MonoException *ex); inline void (*mono_raise_exception)(MonoException *ex);
typedef MonoClass *(*mono_get_exception_class_t)(); inline MonoClass *(*mono_get_exception_class)();
typedef MonoClass *(*mono_get_array_class_t)(); inline MonoClass *(*mono_get_array_class)();
typedef MonoClass *(*mono_get_string_class_t)(); inline MonoClass *(*mono_get_string_class)();
typedef MonoClass *(*mono_get_int32_class_t)(); inline MonoClass *(*mono_get_int32_class)();
typedef MonoArray *(*mono_array_new_t)(MonoDomain *domain, MonoClass *eclass, guint32 n); inline MonoArray *(*mono_array_new)(MonoDomain *domain, MonoClass *eclass, guint32 n);
typedef MonoArray *(*mono_array_new_full_t)(MonoDomain *domain, MonoClass *array_class, guint32 *lengths, guint32 *lower_bounds); inline MonoArray *(*mono_array_new_full)(MonoDomain *domain, MonoClass *array_class, guint32 *lengths, guint32 *lower_bounds);
typedef MonoClass *(*mono_array_class_get_t)(MonoClass *eclass, guint32 rank); inline MonoClass *(*mono_array_class_get)(MonoClass *eclass, guint32 rank);
typedef gint32 (*mono_class_array_element_size_t)(MonoClass *ac); inline gint32 (*mono_class_array_element_size)(MonoClass *ac);
typedef MonoObject *(*mono_type_get_object_t)(MonoDomain *domain, MonoType *type); inline MonoObject *(*mono_type_get_object)(MonoDomain *domain, MonoType *type);
typedef MonoThread *(*mono_thread_attach_t)(MonoDomain *domain); inline MonoThread *(*mono_thread_attach)(MonoDomain *domain);
typedef void (*mono_thread_detach_t)(MonoThread *thread); inline void (*mono_thread_detach)(MonoThread *thread);
typedef MonoThread *(*mono_thread_exit_t)(); inline MonoThread *(*mono_thread_exit)();
typedef MonoThread *(*mono_thread_current_t)(); inline MonoThread *(*mono_thread_current)();
typedef void (*mono_thread_set_main_t)(MonoThread *thread); inline void (*mono_thread_set_main)(MonoThread *thread);
typedef void (*mono_set_find_plugin_callback_t)(gconstpointer method); inline void (*mono_set_find_plugin_callback)(gconstpointer method);
typedef void (*mono_security_enable_core_clr_t)(); inline void (*mono_security_enable_core_clr)();
typedef bool (*mono_security_set_core_clr_platform_callback_t)(MonoCoreClrPlatformCB a); inline bool (*mono_security_set_core_clr_platform_callback)(MonoCoreClrPlatformCB a);
typedef MonoRuntimeUnhandledExceptionPolicy (*mono_runtime_unhandled_exception_policy_get_t)(); inline MonoRuntimeUnhandledExceptionPolicy (*mono_runtime_unhandled_exception_policy_get)();
typedef void (*mono_runtime_unhandled_exception_policy_set_t)(MonoRuntimeUnhandledExceptionPolicy policy); inline void (*mono_runtime_unhandled_exception_policy_set)(MonoRuntimeUnhandledExceptionPolicy policy);
typedef MonoClass *(*mono_class_get_nesting_type_t)(MonoClass *klass); inline MonoClass *(*mono_class_get_nesting_type)(MonoClass *klass);
typedef MonoVTable *(*mono_class_vtable_t)(MonoDomain *domain, MonoClass *klass); inline MonoVTable *(*mono_class_vtable)(MonoDomain *domain, MonoClass *klass);
typedef MonoReflectionMethod *(*mono_method_get_object_t)(MonoDomain *domain, MonoMethod *method, MonoClass *refclass); inline MonoReflectionMethod *(*mono_method_get_object)(MonoDomain *domain, MonoMethod *method, MonoClass *refclass);
typedef MonoMethodSignature *(*mono_method_signature_t)(MonoMethod *method); inline MonoMethodSignature *(*mono_method_signature)(MonoMethod *method);
typedef MonoType *(*mono_signature_get_params_t)(MonoMethodSignature *sig, gpointer *iter); inline MonoType *(*mono_signature_get_params)(MonoMethodSignature *sig, gpointer *iter);
typedef MonoType *(*mono_signature_get_return_type_t)(MonoMethodSignature *sig); inline MonoType *(*mono_signature_get_return_type)(MonoMethodSignature *sig);
typedef MonoType *(*mono_class_get_type_t)(MonoClass *klass); inline MonoType *(*mono_class_get_type)(MonoClass *klass);
typedef void (*mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded_t)(gboolean value); inline void (*mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded)(gboolean value);
typedef void (*mono_debug_init_t)(int format); inline void (*mono_debug_init)(int format);
typedef void (*mono_debug_open_image_from_memory_t)(MonoImage *image, const char *raw_contents, int size); inline void (*mono_debug_open_image_from_memory)(MonoImage *image, const char *raw_contents, int size);
typedef guint32 (*mono_field_get_flags_t)(MonoClassField *field); inline guint32 (*mono_field_get_flags)(MonoClassField *field);
typedef MonoImage *(*mono_image_open_from_data_full_t)(const void *data, guint32 data_len, gboolean need_copy, int *status, gboolean ref_only); inline MonoImage *(*mono_image_open_from_data_full)(const void *data, guint32 data_len, gboolean need_copy, int *status, gboolean ref_only);
typedef MonoImage *(*mono_image_open_from_data_with_name_t)(char *data, guint32 data_len, gboolean need_copy, int *status, gboolean refonly, const char *name); inline MonoImage *(*mono_image_open_from_data_with_name)(char *data, guint32 data_len, gboolean need_copy, int *status, gboolean refonly, const char *name);
typedef MonoAssembly *(*mono_assembly_load_from_t)(MonoImage *image, const char *fname, int *status); inline MonoAssembly *(*mono_assembly_load_from)(MonoImage *image, const char *fname, int *status);
typedef MonoObject *(*mono_value_box_t)(MonoDomain *domain, MonoClass *klass, gpointer val); inline MonoObject *(*mono_value_box)(MonoDomain *domain, MonoClass *klass, gpointer val);
typedef MonoImage *(*mono_class_get_image_t)(MonoClass *klass); inline MonoImage *(*mono_class_get_image)(MonoClass *klass);
typedef char (*mono_signature_is_instance_t)(MonoMethodSignature *signature); inline char (*mono_signature_is_instance)(MonoMethodSignature *signature);
typedef MonoMethod *(*mono_method_get_last_managed_t)(); inline MonoMethod *(*mono_method_get_last_managed)();
typedef MonoClass *(*mono_get_enum_class_t)(); inline MonoClass *(*mono_get_enum_class)();
typedef MonoType *(*mono_class_get_byref_type_t)(MonoClass *klass); inline MonoType *(*mono_class_get_byref_type)(MonoClass *klass);
typedef void (*mono_field_static_get_value_t)(MonoVTable *vt, MonoClassField *field, void *value); inline void (*mono_field_static_get_value)(MonoVTable *vt, MonoClassField *field, void *value);
typedef void (*mono_unity_set_embeddinghostname_t)(const char *name); inline void (*mono_unity_set_embeddinghostname)(const char *name);
typedef void (*mono_set_assemblies_path_t)(const char *name); inline void (*mono_set_assemblies_path)(const char *name);
typedef guint32 (*mono_gchandle_new_t)(MonoObject *obj, gboolean pinned); inline guint32 (*mono_gchandle_new)(MonoObject *obj, gboolean pinned);
typedef MonoObject *(*mono_gchandle_get_target_t)(guint32 gchandle); inline MonoObject *(*mono_gchandle_get_target)(guint32 gchandle);
typedef guint32 (*mono_gchandle_new_weakref_t)(MonoObject *obj, gboolean track_resurrection); inline guint32 (*mono_gchandle_new_weakref)(MonoObject *obj, gboolean track_resurrection);
typedef MonoObject *(*mono_assembly_get_object_t)(MonoDomain *domain, MonoAssembly *assembly); inline MonoObject *(*mono_assembly_get_object)(MonoDomain *domain, MonoAssembly *assembly);
typedef void (*mono_gchandle_free_t)(guint32 gchandle); inline void (*mono_gchandle_free)(guint32 gchandle);
typedef MonoProperty *(*mono_class_get_properties_t)(MonoClass *klass, gpointer *iter); inline MonoProperty *(*mono_class_get_properties)(MonoClass *klass, gpointer *iter);
typedef MonoMethod *(*mono_property_get_get_method_t)(MonoProperty *prop); inline MonoMethod *(*mono_property_get_get_method)(MonoProperty *prop);
typedef MonoObject *(*mono_object_new_alloc_specific_t)(MonoVTable *vtable); inline MonoObject *(*mono_object_new_alloc_specific)(MonoVTable *vtable);
typedef MonoObject *(*mono_object_new_specific_t)(MonoVTable *vtable); inline MonoObject *(*mono_object_new_specific)(MonoVTable *vtable);
typedef void (*mono_gc_collect_t)(int generation); inline void (*mono_gc_collect)(int generation);
typedef int (*mono_gc_max_generation_t)(); inline int (*mono_gc_max_generation)();
typedef MonoAssembly *(*mono_image_get_assembly_t)(MonoImage *image); inline MonoAssembly *(*mono_image_get_assembly)(MonoImage *image);
typedef MonoAssembly *(*mono_assembly_open_t)(const char *filename, int *status); inline MonoAssembly *(*mono_assembly_open)(const char *filename, int *status);
typedef gboolean (*mono_class_is_enum_t)(MonoClass *klass); inline gboolean (*mono_class_is_enum)(MonoClass *klass);
typedef gint32 (*mono_class_instance_size_t)(MonoClass *klass); inline gint32 (*mono_class_instance_size)(MonoClass *klass);
typedef guint32 (*mono_object_get_size_t)(MonoObject *obj); inline guint32 (*mono_object_get_size)(MonoObject *obj);
typedef const char *(*mono_image_get_filename_t)(MonoImage *image); inline const char *(*mono_image_get_filename)(MonoImage *image);
typedef MonoAssembly *(*mono_assembly_load_from_full_t)(MonoImage *image, const char *fname, int *status, gboolean refonly); inline MonoAssembly *(*mono_assembly_load_from_full)(MonoImage *image, const char *fname, int *status, gboolean refonly);
typedef MonoClass *(*mono_class_get_interfaces_t)(MonoClass *klass, gpointer *iter); inline MonoClass *(*mono_class_get_interfaces)(MonoClass *klass, gpointer *iter);
typedef void (*mono_assembly_close_t)(MonoAssembly *assembly); inline void (*mono_assembly_close)(MonoAssembly *assembly);
typedef MonoProperty *(*mono_class_get_property_from_name_t)(MonoClass *klass, const char *name); inline MonoProperty *(*mono_class_get_property_from_name)(MonoClass *klass, const char *name);
typedef MonoMethod *(*mono_class_get_method_from_name_t)(MonoClass *klass, const char *name, int param_count); inline MonoMethod *(*mono_class_get_method_from_name)(MonoClass *klass, const char *name, int param_count);
typedef MonoClass *(*mono_class_from_mono_type_t)(MonoType *image); inline MonoClass *(*mono_class_from_mono_type)(MonoType *image);
typedef gboolean (*mono_domain_set_t)(MonoDomain *domain, gboolean force); inline gboolean (*mono_domain_set)(MonoDomain *domain, gboolean force);
typedef void (*mono_thread_push_appdomain_ref_t)(MonoDomain *domain); inline void (*mono_thread_push_appdomain_ref)(MonoDomain *domain);
typedef void (*mono_thread_pop_appdomain_ref_t)(); inline void (*mono_thread_pop_appdomain_ref)();
typedef int (*mono_runtime_exec_main_t)(MonoMethod *method, MonoArray *args, MonoObject **exc); inline int (*mono_runtime_exec_main)(MonoMethod *method, MonoArray *args, MonoObject **exc);
typedef MonoImage *(*mono_get_corlib_t)(); inline MonoImage *(*mono_get_corlib)();
typedef MonoClassField *(*mono_class_get_field_from_name_t)(MonoClass *klass, const char *name); inline MonoClassField *(*mono_class_get_field_from_name)(MonoClass *klass, const char *name);
typedef guint32 (*mono_class_get_flags_t)(MonoClass *klass); inline guint32 (*mono_class_get_flags)(MonoClass *klass);
typedef int (*mono_parse_default_optimizations_t)(const char *p); inline int (*mono_parse_default_optimizations)(const char *p);
typedef void (*mono_set_defaults_t)(int verbose_level, guint32 opts); inline void (*mono_set_defaults)(int verbose_level, guint32 opts);
typedef void (*mono_set_dirs_t)(const char *assembly_dir, const char *config_dir); inline void (*mono_set_dirs)(const char *assembly_dir, const char *config_dir);
typedef void (*mono_jit_parse_options_t)(int argc, char *argv[]); inline void (*mono_jit_parse_options)(int argc, char *argv[]);
typedef gpointer (*mono_object_unbox_t)(MonoObject *o); inline gpointer (*mono_object_unbox)(MonoObject *o);
typedef MonoObject *(*mono_custom_attrs_get_attr_t)(MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); inline MonoObject *(*mono_custom_attrs_get_attr)(MonoCustomAttrInfo *ainfo, MonoClass *attr_klass);
typedef gboolean (*mono_custom_attrs_has_attr_t)(MonoCustomAttrInfo *ainfo, MonoClass *attr_klass); inline gboolean (*mono_custom_attrs_has_attr)(MonoCustomAttrInfo *ainfo, MonoClass *attr_klass);
typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_field_t)(MonoClass *klass, MonoClassField *field); inline MonoCustomAttrInfo *(*mono_custom_attrs_from_field)(MonoClass *klass, MonoClassField *field);
typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_method_t)(MonoMethod *method); inline MonoCustomAttrInfo *(*mono_custom_attrs_from_method)(MonoMethod *method);
typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_class_t)(MonoClass *klass); inline MonoCustomAttrInfo *(*mono_custom_attrs_from_class)(MonoClass *klass);
typedef void (*mono_custom_attrs_free_t)(MonoCustomAttrInfo *attr); inline void (*mono_custom_attrs_free)(MonoCustomAttrInfo *attr);
typedef void (*g_free_t)(void *p); inline void (*g_free)(void *p);
typedef gboolean (*mono_runtime_is_shutting_down_t)(); inline gboolean (*mono_runtime_is_shutting_down)();
typedef MonoMethod *(*mono_object_get_virtual_method_t)(MonoObject *obj, MonoMethod *method); inline MonoMethod *(*mono_object_get_virtual_method)(MonoObject *obj, MonoMethod *method);
typedef gpointer (*mono_jit_info_get_code_start_t)(MonoJitInfo *ji); inline gpointer (*mono_jit_info_get_code_start)(MonoJitInfo *ji);
typedef int (*mono_jit_info_get_code_size_t)(MonoJitInfo *ji); inline int (*mono_jit_info_get_code_size)(MonoJitInfo *ji);
typedef MonoClass *(*mono_class_from_name_case_t)(MonoImage *image, const char *name_space, const char *name); inline MonoClass *(*mono_class_from_name_case)(MonoImage *image, const char *name_space, const char *name);
typedef MonoClass *(*mono_class_get_nested_types_t)(MonoClass *klass, gpointer *iter); inline MonoClass *(*mono_class_get_nested_types)(MonoClass *klass, gpointer *iter);
typedef int (*mono_class_get_userdata_offset_t)(); inline int (*mono_class_get_userdata_offset)();
typedef void *(*mono_class_get_userdata_t)(MonoClass *klass); inline void *(*mono_class_get_userdata)(MonoClass *klass);
typedef void (*mono_class_set_userdata_t)(MonoClass *klass, void *userdata); inline void (*mono_class_set_userdata)(MonoClass *klass, void *userdata);
typedef void (*mono_set_signal_chaining_t)(gboolean chain_signals); inline void (*mono_set_signal_chaining)(gboolean chain_signals);
// typedef LONG( *mono_unity_seh_handler_t)(EXCEPTION_POINTERS* ep); inline void (*mono_unity_set_unhandled_exception_handler)(void *handler);
typedef void (*mono_unity_set_unhandled_exception_handler_t)(void *handler); inline MonoObject *(*mono_runtime_invoke_array)(MonoMethod *method, void *obj, MonoArray *params, MonoObject **exc);
typedef MonoObject *(*mono_runtime_invoke_array_t)(MonoMethod *method, void *obj, MonoArray *params, MonoObject **exc); inline char *(*mono_array_addr_with_size)(MonoArray *array, int size, uintptr_t idx);
typedef char *(*mono_array_addr_with_size_t)(MonoArray *array, int size, uintptr_t idx); inline gunichar2 *(*mono_string_to_utf16)(MonoString *string_obj);
typedef gunichar2 *(*mono_string_to_utf16_t)(MonoString *string_obj); inline MonoClass *(*mono_field_get_parent)(MonoClassField *field);
typedef MonoClass *(*mono_field_get_parent_t)(MonoClassField *field); inline char *(*mono_method_full_name)(MonoMethod *method, gboolean signature);
typedef char *(*mono_method_full_name_t)(MonoMethod *method, gboolean signature); inline MonoObject *(*mono_object_isinst)(MonoObject *obj, MonoClass *klass);
typedef MonoObject *(*mono_object_isinst_t)(MonoObject *obj, MonoClass *klass); inline MonoString *(*mono_string_new_len)(MonoDomain *domain, const char *text, guint length);
typedef MonoString *(*mono_string_new_len_t)(MonoDomain *domain, const char *text, guint length); inline MonoString *(*mono_string_from_utf16)(gunichar2 *data);
typedef MonoString *(*mono_string_from_utf16_t)(gunichar2 *data); inline MonoString* (*mono_string_new_utf16)(MonoDomain *domain, const gunichar2 *text, int32_t len);
typedef MonoException *(*mono_get_exception_argument_null_t)(const char *arg); inline MonoException *(*mono_get_exception_argument_null)(const char *arg);
typedef MonoClass *(*mono_get_boolean_class_t)(); inline MonoClass *(*mono_get_boolean_class)();
typedef MonoClass *(*mono_get_byte_class_t)(); inline MonoClass *(*mono_get_byte_class)();
typedef MonoClass *(*mono_get_char_class_t)(); inline MonoClass *(*mono_get_char_class)();
typedef MonoClass *(*mono_get_int16_class_t)(); inline MonoClass *(*mono_get_int16_class)();
typedef MonoClass *(*mono_get_int64_class_t)(); inline MonoClass *(*mono_get_int64_class)();
typedef MonoClass *(*mono_get_single_class_t)(); inline MonoClass *(*mono_get_single_class)();
typedef MonoClass *(*mono_get_double_class_t)(); inline MonoClass *(*mono_get_double_class)();
typedef gboolean (*mono_class_is_generic_t)(MonoClass *klass); inline gboolean (*mono_class_is_generic)(MonoClass *klass);
typedef gboolean (*mono_class_is_inflated_t)(MonoClass *klass); inline gboolean (*mono_class_is_inflated)(MonoClass *klass);
typedef gboolean (*unity_mono_method_is_generic_t)(MonoMethod *method); inline gboolean (*unity_mono_method_is_generic)(MonoMethod *method);
typedef gboolean (*unity_mono_method_is_inflated_t)(MonoMethod *method); inline gboolean (*unity_mono_method_is_inflated)(MonoMethod *method);
typedef gboolean (*mono_is_debugger_attached_t)(); inline gboolean (*mono_is_debugger_attached)();
typedef gboolean (*mono_assembly_fill_assembly_name_t)(MonoImage *image, MonoAssemblyName *aname); inline gboolean (*mono_assembly_fill_assembly_name)(MonoImage *image, MonoAssemblyName *aname);
typedef char *(*mono_stringify_assembly_name_t)(MonoAssemblyName *aname); inline char *(*mono_stringify_assembly_name)(MonoAssemblyName *aname);
typedef gboolean (*mono_assembly_name_parse_t)(const char *name, MonoAssemblyName *aname); inline gboolean (*mono_assembly_name_parse)(const char *name, MonoAssemblyName *aname);
typedef MonoAssembly *(*mono_assembly_loaded_t)(MonoAssemblyName *aname); inline MonoAssembly *(*mono_assembly_loaded)(MonoAssemblyName *aname);
typedef int (*mono_image_get_table_rows_t)(MonoImage *image, int table_id); inline int (*mono_image_get_table_rows)(MonoImage *image, int table_id);
typedef MonoClass *(*mono_class_get_t)(MonoImage *image, guint32 type_token); inline MonoClass *(*mono_class_get)(MonoImage *image, guint32 type_token);
typedef gboolean (*mono_metadata_signature_equal_t)(MonoMethodSignature *sig1, MonoMethodSignature *sig2); inline gboolean (*mono_metadata_signature_equal)(MonoMethodSignature *sig1, MonoMethodSignature *sig2);
typedef gboolean (*mono_gchandle_is_in_domain_t)(guint32 gchandle, MonoDomain *domain); inline gboolean (*mono_gchandle_is_in_domain)(guint32 gchandle, MonoDomain *domain);
typedef void (*mono_stack_walk_t)(MonoStackWalk func, gpointer user_data); inline void (*mono_stack_walk)(MonoStackWalk func, gpointer user_data);
typedef char *(*mono_pmip_t)(void *ip); inline char *(*mono_pmip)(void *ip);
typedef MonoObject *(*mono_runtime_delegate_invoke_t)(MonoObject *delegate, void **params, MonoObject **exc); inline MonoObject *(*mono_runtime_delegate_invoke)(MonoObject *delegate, void **params, MonoObject **exc);
typedef MonoJitInfo *(*mono_jit_info_table_find_t)(MonoDomain *domain, char *addr); inline MonoJitInfo *(*mono_jit_info_table_find)(MonoDomain *domain, char *addr);
typedef MonoDebugSourceLocation *(*mono_debug_lookup_source_location_t)(MonoMethod *method, guint32 address, MonoDomain *domain); inline MonoDebugSourceLocation *(*mono_debug_lookup_source_location)(MonoMethod *method, guint32 address, MonoDomain *domain);
typedef void (*mono_debug_free_source_location_t)(MonoDebugSourceLocation *location); inline void (*mono_debug_free_source_location)(MonoDebugSourceLocation *location);
typedef void (*mono_gc_wbarrier_generic_store_t)(gpointer ptr, MonoObject *value); inline void (*mono_gc_wbarrier_generic_store)(gpointer ptr, MonoObject *value);
typedef MonoType *(*mono_class_enum_basetype_t)(MonoClass *klass); inline MonoType *(*mono_class_enum_basetype)(MonoClass *klass);
typedef guint32 (*mono_class_get_type_token_t)(MonoClass *klass); inline guint32 (*mono_class_get_type_token)(MonoClass *klass);
typedef int (*mono_class_get_rank_t)(MonoClass *klass); inline int (*mono_class_get_rank)(MonoClass *klass);
typedef MonoClass *(*mono_class_get_element_class_t)(MonoClass *klass); inline MonoClass *(*mono_class_get_element_class)(MonoClass *klass);
typedef gboolean (*mono_unity_class_is_interface_t)(MonoClass *klass); inline gboolean (*mono_unity_class_is_interface)(MonoClass *klass);
typedef gboolean (*mono_unity_class_is_abstract_t)(MonoClass *klass); inline gboolean (*mono_unity_class_is_abstract)(MonoClass *klass);
typedef gint32 (*mono_array_element_size_t)(MonoClass *ac); inline gint32 (*mono_array_element_size)(MonoClass *ac);
typedef void (*mono_config_parse_t)(const char *filename); inline void (*mono_config_parse)(const char *filename);
typedef void (*mono_set_break_policy_t)(MonoBreakPolicyFunc policy_callback); inline void (*mono_set_break_policy)(MonoBreakPolicyFunc policy_callback);
typedef MonoArray *(*mono_custom_attrs_construct_t)(MonoCustomAttrInfo *cinfo); inline MonoArray *(*mono_custom_attrs_construct)(MonoCustomAttrInfo *cinfo);
typedef MonoCustomAttrInfo *(*mono_custom_attrs_from_assembly_t)(MonoAssembly *assembly); inline MonoCustomAttrInfo *(*mono_custom_attrs_from_assembly)(MonoAssembly *assembly);
typedef MonoArray *(*mono_reflection_get_custom_attrs_by_type_t)(MonoObject *obj, MonoClass *attr_klass); inline MonoArray *(*mono_reflection_get_custom_attrs_by_type)(MonoObject *obj, MonoClass *attr_klass);
typedef MonoLoaderError *(*mono_loader_get_last_error_t)(); inline MonoLoaderError *(*mono_loader_get_last_error)();
typedef MonoException *(*mono_loader_error_prepare_exception_t)(MonoLoaderError *error); inline MonoException *(*mono_loader_error_prepare_exception)(MonoLoaderError *error);
typedef MonoDlFallbackHandler *(*mono_dl_fallback_register_t)(MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, MonoDlFallbackClose close_func, void *user_data); inline MonoDlFallbackHandler *(*mono_dl_fallback_register)(MonoDlFallbackLoad load_func, MonoDlFallbackSymbol symbol_func, MonoDlFallbackClose close_func, void *user_data);
typedef void (*mono_dl_fallback_unregister_t)(MonoDlFallbackHandler *handler); inline void (*mono_dl_fallback_unregister)(MonoDlFallbackHandler *handler);
typedef LivenessState *(*mono_unity_liveness_allocate_struct_t)(MonoClass *filter, guint max_count, register_object_callback callback, void *callback_userdata); inline LivenessState *(*mono_unity_liveness_allocate_struct)(MonoClass *filter, guint max_count, register_object_callback callback, void *callback_userdata);
typedef void (*mono_unity_liveness_stop_gc_world_t)(); inline void (*mono_unity_liveness_stop_gc_world)();
typedef void (*mono_unity_liveness_finalize_t)(LivenessState *state); inline void (*mono_unity_liveness_finalize)(LivenessState *state);
typedef void (*mono_unity_liveness_start_gc_world_t)(); inline void (*mono_unity_liveness_start_gc_world)();
typedef void (*mono_unity_liveness_free_struct_t)(LivenessState *state); inline void (*mono_unity_liveness_free_struct)(LivenessState *state);
typedef LivenessState *(*mono_unity_liveness_calculation_begin_t)(MonoClass *filter, guint max_count, register_object_callback callback, void *callback_userdata); inline LivenessState *(*mono_unity_liveness_calculation_begin)(MonoClass *filter, guint max_count, register_object_callback callback, void *callback_userdata);
typedef void (*mono_unity_liveness_calculation_end_t)(LivenessState *state); inline void (*mono_unity_liveness_calculation_end)(LivenessState *state);
typedef void (*mono_unity_liveness_calculation_from_root_t)(MonoObject *root, LivenessState *state); inline void (*mono_unity_liveness_calculation_from_root)(MonoObject *root, LivenessState *state);
typedef void (*mono_unity_liveness_calculation_from_statics_t)(LivenessState *state); inline void (*mono_unity_liveness_calculation_from_statics)(LivenessState *state);
typedef void (*mono_trace_set_level_string_t)(const char *value); inline void (*mono_trace_set_level_string)(const char *value);
typedef void (*mono_trace_set_mask_string_t)(char *value); inline void (*mono_trace_set_mask_string)(char *value);
typedef gint64 (*mono_gc_get_used_size_t)(); inline gint64 (*mono_gc_get_used_size)();
typedef gint64 (*mono_gc_get_heap_size_t)(); inline gint64 (*mono_gc_get_heap_size)();
typedef MonoMethod *(*mono_method_desc_search_in_class_t)(MonoMethodDesc *desc, MonoClass *klass); inline MonoMethod *(*mono_method_desc_search_in_class)(MonoMethodDesc *desc, MonoClass *klass);
typedef void (*mono_method_desc_free_t)(MonoMethodDesc *desc); inline void (*mono_method_desc_free)(MonoMethodDesc *desc);
typedef char *(*mono_type_get_name_full_t)(MonoType *type, MonoTypeNameFormat format); inline char *(*mono_type_get_name_full)(MonoType *type, MonoTypeNameFormat format);
typedef void (*mono_unity_thread_clear_domain_fields_t)(); inline void (*mono_unity_thread_clear_domain_fields)();
// typedef void( *mono_unity_set_vprintf_func_t)(vprintf_func func); inline void (*mono_profiler_install)(MonoProfiler *prof, MonoProfileFunc shutdown_callback);
typedef void (*mono_profiler_install_t)(MonoProfiler *prof, MonoProfileFunc shutdown_callback); inline void (*mono_profiler_set_events)(MonoProfileFlags events);
typedef void (*mono_profiler_set_events_t)(MonoProfileFlags events); inline void (*mono_profiler_install_enter_leave)(MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave);
typedef void (*mono_profiler_install_enter_leave_t)(MonoProfileMethodFunc enter, MonoProfileMethodFunc fleave); inline void (*mono_profiler_install_gc)(MonoProfileGCFunc callback, MonoProfileGCResizeFunc heap_resize_callback);
typedef void (*mono_profiler_install_gc_t)(MonoProfileGCFunc callback, MonoProfileGCResizeFunc heap_resize_callback); inline void (*mono_profiler_install_allocation)(MonoProfileAllocFunc callback);
typedef void (*mono_profiler_install_allocation_t)(MonoProfileAllocFunc callback); inline void (*mono_profiler_install_jit_end)(MonoProfileJitResult end);
typedef void (*mono_profiler_install_jit_end_t)(MonoProfileJitResult end); inline void (*mono_profiler_install_exception)(MonoProfileExceptionFunc throw_callback, MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback);
typedef void (*mono_profiler_install_exception_t)(MonoProfileExceptionFunc throw_callback, MonoProfileMethodFunc exc_method_leave, MonoProfileExceptionClauseFunc clause_callback); inline void (*mono_profiler_install_thread)(MonoProfileThreadFunc start, MonoProfileThreadFunc end);
typedef void (*mono_profiler_install_thread_t)(MonoProfileThreadFunc start, MonoProfileThreadFunc end); inline uint64_t* (*mono_compile_method)(MonoMethod*);
typedef uint64_t* (*mono_compile_method_t)(uintptr_t); inline MonoTableInfo*(*mono_image_get_table_info)(MonoImage*,int);
inline int (*mono_table_info_get_rows)(MonoTableInfo*);
inline gunichar2* (*mono_string_chars)(MonoString* str);
inline int (*mono_string_length)(MonoString* str);
typedef void*(*mono_image_get_table_info_t)(void*,uint32_t);
typedef int (*mono_table_info_get_rows_t)(void*); namespace monofunctions{
void init(HMODULE dll);
uintptr_t get_method_pointer(const char* assemblyName, const char* namespaze,
const char* klassName, const char* name, int argsCount,bool strict);
std::optional<std::wstring_view> get_string(void*);
void* create_string(std::wstring_view ws);
}

129
LunaHook/engines/mono/impl_il2cpp.cpp
View File

@ -1,77 +1,11 @@
#include"def_il2cpp.hpp"
namespace{
il2cpp_string_new_utf16_t il2cpp_string_new_utf16;
il2cpp_string_new_t il2cpp_string_new;
il2cpp_domain_get_t il2cpp_domain_get;
il2cpp_domain_assembly_open_t il2cpp_domain_assembly_open;
il2cpp_assembly_get_image_t il2cpp_assembly_get_image;
il2cpp_class_from_name_t il2cpp_class_from_name;
il2cpp_class_get_methods_t il2cpp_class_get_methods;
il2cpp_class_get_method_from_name_t il2cpp_class_get_method_from_name;
il2cpp_method_get_param_t il2cpp_method_get_param;
il2cpp_object_new_t il2cpp_object_new;
il2cpp_resolve_icall_t il2cpp_resolve_icall;
il2cpp_array_new_t il2cpp_array_new;
il2cpp_thread_attach_t il2cpp_thread_attach;
il2cpp_thread_detach_t il2cpp_thread_detach;
il2cpp_class_get_field_from_name_t il2cpp_class_get_field_from_name;
il2cpp_class_is_assignable_from_t il2cpp_class_is_assignable_from;
il2cpp_class_for_each_t il2cpp_class_for_each;
il2cpp_class_get_nested_types_t il2cpp_class_get_nested_types;
il2cpp_class_get_type_t il2cpp_class_get_type;
il2cpp_type_get_object_t il2cpp_type_get_object;
il2cpp_gchandle_new_t il2cpp_gchandle_new;
il2cpp_gchandle_free_t il2cpp_gchandle_free;
il2cpp_gchandle_get_target_t il2cpp_gchandle_get_target;
il2cpp_class_from_type_t il2cpp_class_from_type;
il2cpp_runtime_class_init_t il2cpp_runtime_class_init;
il2cpp_runtime_invoke_t il2cpp_runtime_invoke;
il2cpp_class_get_name_t il2cpp_class_get_name;
il2cpp_class_get_namespace_t il2cpp_class_get_namespace;
il2cpp_domain_get_assemblies_t il2cpp_domain_get_assemblies;
il2cpp_class_get_image_t il2cpp_class_get_image;
il2cpp_image_get_name_t il2cpp_image_get_name;
namespace il2cpp_symbols
{
#define RESOLVE_IMPORT(name) name = reinterpret_cast<name##_t>(GetProcAddress(game_module, #name))
void init(HMODULE game_module)
{
RESOLVE_IMPORT(il2cpp_image_get_name);
RESOLVE_IMPORT(il2cpp_class_get_image);
RESOLVE_IMPORT(il2cpp_string_new_utf16);
RESOLVE_IMPORT(il2cpp_string_new);
RESOLVE_IMPORT(il2cpp_domain_get);
RESOLVE_IMPORT(il2cpp_domain_assembly_open);
RESOLVE_IMPORT(il2cpp_assembly_get_image);
RESOLVE_IMPORT(il2cpp_class_from_name);
RESOLVE_IMPORT(il2cpp_class_get_methods);
RESOLVE_IMPORT(il2cpp_class_get_method_from_name);
RESOLVE_IMPORT(il2cpp_method_get_param);
RESOLVE_IMPORT(il2cpp_object_new);
RESOLVE_IMPORT(il2cpp_resolve_icall);
RESOLVE_IMPORT(il2cpp_array_new);
RESOLVE_IMPORT(il2cpp_thread_attach);
RESOLVE_IMPORT(il2cpp_thread_detach);
RESOLVE_IMPORT(il2cpp_class_get_field_from_name);
RESOLVE_IMPORT(il2cpp_class_is_assignable_from);
RESOLVE_IMPORT(il2cpp_class_for_each);
RESOLVE_IMPORT(il2cpp_class_get_nested_types);
RESOLVE_IMPORT(il2cpp_class_get_type);
RESOLVE_IMPORT(il2cpp_type_get_object);
RESOLVE_IMPORT(il2cpp_gchandle_new);
RESOLVE_IMPORT(il2cpp_gchandle_free);
RESOLVE_IMPORT(il2cpp_gchandle_get_target);
RESOLVE_IMPORT(il2cpp_class_from_type);
RESOLVE_IMPORT(il2cpp_runtime_class_init);
RESOLVE_IMPORT(il2cpp_runtime_invoke);
RESOLVE_IMPORT(il2cpp_class_get_name);
RESOLVE_IMPORT(il2cpp_class_get_namespace);
RESOLVE_IMPORT(il2cpp_domain_get_assemblies);
}
Il2CppClass* get_il2cppclass1(const char* assemblyName, const char* namespaze, Il2CppClass* get_il2cppclass1(const char* assemblyName, const char* namespaze,
const char* klassName,bool strict) const char* klassName,bool strict)
{ {
auto il2cpp_domain=(SafeFptr(il2cpp_domain_get))();
if (!il2cpp_domain) return NULL;
void* assembly=0; void* assembly=0;
do{ do{
assembly = (SafeFptr(il2cpp_domain_assembly_open))(il2cpp_domain, assemblyName); assembly = (SafeFptr(il2cpp_domain_assembly_open))(il2cpp_domain, assemblyName);
@ -148,9 +82,47 @@ namespace il2cpp_symbols
tryprintimage(klass); tryprintimage(klass);
return ret->methodPointer; return ret->methodPointer;
} }
uintptr_t get_method_pointer(const char* assemblyName, const char* namespaze, }
void il2cppfunctions::init(HMODULE game_module)
{
RESOLVE_IMPORT(il2cpp_string_new_utf16);
RESOLVE_IMPORT(il2cpp_string_chars);
RESOLVE_IMPORT(il2cpp_string_length);
RESOLVE_IMPORT(il2cpp_image_get_name);
RESOLVE_IMPORT(il2cpp_class_get_image);
RESOLVE_IMPORT(il2cpp_string_new_utf16);
RESOLVE_IMPORT(il2cpp_string_new);
RESOLVE_IMPORT(il2cpp_domain_get);
RESOLVE_IMPORT(il2cpp_domain_assembly_open);
RESOLVE_IMPORT(il2cpp_assembly_get_image);
RESOLVE_IMPORT(il2cpp_class_from_name);
RESOLVE_IMPORT(il2cpp_class_get_methods);
RESOLVE_IMPORT(il2cpp_class_get_method_from_name);
RESOLVE_IMPORT(il2cpp_method_get_param);
RESOLVE_IMPORT(il2cpp_object_new);
RESOLVE_IMPORT(il2cpp_resolve_icall);
RESOLVE_IMPORT(il2cpp_array_new);
RESOLVE_IMPORT(il2cpp_thread_attach);
RESOLVE_IMPORT(il2cpp_thread_detach);
RESOLVE_IMPORT(il2cpp_class_get_field_from_name);
RESOLVE_IMPORT(il2cpp_class_is_assignable_from);
RESOLVE_IMPORT(il2cpp_class_for_each);
RESOLVE_IMPORT(il2cpp_class_get_nested_types);
RESOLVE_IMPORT(il2cpp_class_get_type);
RESOLVE_IMPORT(il2cpp_type_get_object);
RESOLVE_IMPORT(il2cpp_gchandle_new);
RESOLVE_IMPORT(il2cpp_gchandle_free);
RESOLVE_IMPORT(il2cpp_gchandle_get_target);
RESOLVE_IMPORT(il2cpp_class_from_type);
RESOLVE_IMPORT(il2cpp_runtime_class_init);
RESOLVE_IMPORT(il2cpp_runtime_invoke);
RESOLVE_IMPORT(il2cpp_class_get_name);
RESOLVE_IMPORT(il2cpp_class_get_namespace);
RESOLVE_IMPORT(il2cpp_domain_get_assemblies);
}
uintptr_t il2cppfunctions::get_method_pointer(const char* assemblyName, const char* namespaze,
const char* klassName, const char* name, int argsCount,bool strict) const char* klassName, const char* name, int argsCount,bool strict)
{ {
auto thread=AutoThread(); auto thread=AutoThread();
if(!thread.thread)return NULL; if(!thread.thread)return NULL;
@ -164,5 +136,16 @@ namespace il2cpp_symbols
if(method)return method; if(method)return method;
} }
return NULL; return NULL;
} }
std::optional<std::wstring_view> il2cppfunctions::get_string(void* ptr){
auto str=reinterpret_cast<Il2CppString*>(ptr);
if(!str)return {};
auto wc=(SafeFptr(il2cpp_string_chars))(str);
auto len=(SafeFptr(il2cpp_string_length))(str);
if(!(wc&&len))return {};
return std::wstring_view(wc,len);
}
void* il2cppfunctions::create_string(std::wstring_view ws){
return (SafeFptr(il2cpp_string_new_utf16))(ws.data(),ws.length());
} }

650
LunaHook/engines/mono/impl_mono.cpp
View File

@ -1,485 +1,18 @@
#include"def_mono.hpp"
mono_compile_method_t mono_compile_method=nullptr;
mono_thread_suspend_all_other_threads_t mono_thread_suspend_all_other_threads = nullptr;
mono_thread_pool_cleanup_t mono_thread_pool_cleanup = nullptr;
mono_threads_set_shutting_down_t mono_threads_set_shutting_down = nullptr;
mono_runtime_set_shutting_down_t mono_runtime_set_shutting_down = nullptr;
mono_domain_finalize_t mono_domain_finalize = nullptr;
mono_runtime_cleanup_t mono_runtime_cleanup = nullptr;
mono_method_desc_new_t mono_method_desc_new = nullptr;
mono_method_desc_search_in_image_t mono_method_desc_search_in_image = nullptr;
mono_verifier_set_mode_t mono_verifier_set_mode = nullptr;
mono_security_set_mode_t mono_security_set_mode = nullptr;
mono_add_internal_call_t mono_add_internal_call = nullptr;
mono_jit_cleanup_t mono_jit_cleanup = nullptr;
mono_jit_init_t mono_jit_init = nullptr;
mono_jit_init_version_t mono_jit_init_version = nullptr;
mono_jit_exec_t mono_jit_exec = nullptr;
mono_class_from_name_t mono_class_from_name = nullptr;
mono_domain_assembly_open_t mono_domain_assembly_open = nullptr;
mono_domain_create_appdomain_t mono_domain_create_appdomain = nullptr;
mono_domain_unload_t mono_domain_unload = nullptr;
mono_object_new_t mono_object_new = nullptr;
mono_runtime_object_init_t mono_runtime_object_init = nullptr;
mono_runtime_invoke_t mono_runtime_invoke = nullptr;
mono_field_set_value_t mono_field_set_value = nullptr;
mono_field_get_value_t mono_field_get_value = nullptr;
mono_field_get_offset_t mono_field_get_offset = nullptr;
mono_class_get_fields_t mono_class_get_fields = nullptr;
mono_class_get_methods_t mono_class_get_methods = nullptr;
mono_domain_get_t mono_domain_get = nullptr;
mono_get_root_domain_t mono_get_root_domain = nullptr;
mono_domain_get_id_t mono_domain_get_id = nullptr;
mono_assembly_foreach_t mono_assembly_foreach = nullptr;
mono_image_close_t mono_image_close = nullptr;
mono_unity_socket_security_enabled_set_t mono_unity_socket_security_enabled_set = nullptr;
mono_image_get_name_t mono_image_get_name = nullptr;
mono_get_object_class_t mono_get_object_class = nullptr;
mono_set_commandline_arguments_t mono_set_commandline_arguments = nullptr;
mono_field_get_name_t mono_field_get_name = nullptr;
mono_field_get_type_t mono_field_get_type = nullptr;
mono_type_get_type_t mono_type_get_type = nullptr;
mono_method_get_name_t mono_method_get_name = nullptr;
mono_assembly_get_image_t mono_assembly_get_image = nullptr;
mono_method_get_class_t mono_method_get_class = nullptr;
mono_object_get_class_t mono_object_get_class = nullptr;
mono_class_is_valuetype_t mono_class_is_valuetype = nullptr;
mono_signature_get_param_count_t mono_signature_get_param_count = nullptr;
mono_string_to_utf8_t mono_string_to_utf8 = nullptr;
mono_string_new_wrapper_t mono_string_new_wrapper = nullptr;
mono_class_get_parent_t mono_class_get_parent = nullptr;
mono_class_get_namespace_t mono_class_get_namespace = nullptr;
mono_class_is_subclass_of_t mono_class_is_subclass_of = nullptr;
mono_class_get_name_t mono_class_get_name = nullptr;
mono_type_get_name_t mono_type_get_name = nullptr;
mono_type_get_class_t mono_type_get_class = nullptr;
mono_exception_from_name_msg_t mono_exception_from_name_msg = nullptr;
mono_raise_exception_t mono_raise_exception = nullptr;
mono_get_exception_class_t mono_get_exception_class = nullptr;
mono_get_array_class_t mono_get_array_class = nullptr;
mono_get_string_class_t mono_get_string_class = nullptr;
mono_get_int32_class_t mono_get_int32_class = nullptr;
mono_array_new_t mono_array_new = nullptr;
mono_array_new_full_t mono_array_new_full = nullptr;
mono_array_class_get_t mono_array_class_get = nullptr;
mono_class_array_element_size_t mono_class_array_element_size = nullptr;
mono_type_get_object_t mono_type_get_object = nullptr;
mono_thread_attach_t mono_thread_attach = nullptr;
mono_thread_detach_t mono_thread_detach = nullptr;
mono_thread_exit_t mono_thread_exit = nullptr;
mono_thread_current_t mono_thread_current = nullptr;
mono_thread_set_main_t mono_thread_set_main = nullptr;
mono_set_find_plugin_callback_t mono_set_find_plugin_callback = nullptr;
mono_security_enable_core_clr_t mono_security_enable_core_clr = nullptr;
mono_security_set_core_clr_platform_callback_t mono_security_set_core_clr_platform_callback = nullptr;
mono_runtime_unhandled_exception_policy_get_t mono_runtime_unhandled_exception_policy_get = nullptr;
mono_runtime_unhandled_exception_policy_set_t mono_runtime_unhandled_exception_policy_set = nullptr;
mono_class_get_nesting_type_t mono_class_get_nesting_type = nullptr;
mono_class_vtable_t mono_class_vtable = nullptr;
mono_method_get_object_t mono_method_get_object = nullptr;
mono_method_signature_t mono_method_signature = nullptr;
mono_signature_get_params_t mono_signature_get_params = nullptr;
mono_signature_get_return_type_t mono_signature_get_return_type = nullptr;
mono_class_get_type_t mono_class_get_type = nullptr;
mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded_t mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded = nullptr;
mono_debug_init_t mono_debug_init = nullptr;
mono_debug_open_image_from_memory_t mono_debug_open_image_from_memory = nullptr;
mono_field_get_flags_t mono_field_get_flags = nullptr;
mono_image_open_from_data_full_t mono_image_open_from_data_full = nullptr;
mono_image_open_from_data_with_name_t mono_image_open_from_data_with_name = nullptr;
mono_assembly_load_from_t mono_assembly_load_from = nullptr;
mono_value_box_t mono_value_box = nullptr;
mono_class_get_image_t mono_class_get_image = nullptr;
mono_signature_is_instance_t mono_signature_is_instance = nullptr;
mono_method_get_last_managed_t mono_method_get_last_managed = nullptr;
mono_get_enum_class_t mono_get_enum_class = nullptr;
mono_class_get_byref_type_t mono_class_get_byref_type = nullptr;
mono_field_static_get_value_t mono_field_static_get_value = nullptr;
mono_unity_set_embeddinghostname_t mono_unity_set_embeddinghostname = nullptr;
mono_set_assemblies_path_t mono_set_assemblies_path = nullptr;
mono_gchandle_new_t mono_gchandle_new = nullptr;
mono_gchandle_get_target_t mono_gchandle_get_target = nullptr;
mono_gchandle_new_weakref_t mono_gchandle_new_weakref = nullptr;
mono_assembly_get_object_t mono_assembly_get_object = nullptr;
mono_gchandle_free_t mono_gchandle_free = nullptr;
mono_class_get_properties_t mono_class_get_properties = nullptr;
mono_property_get_get_method_t mono_property_get_get_method = nullptr;
mono_object_new_alloc_specific_t mono_object_new_alloc_specific = nullptr;
mono_object_new_specific_t mono_object_new_specific = nullptr;
mono_gc_collect_t mono_gc_collect = nullptr;
mono_gc_max_generation_t mono_gc_max_generation = nullptr;
mono_image_get_assembly_t mono_image_get_assembly = nullptr;
mono_assembly_open_t mono_assembly_open = nullptr;
mono_class_is_enum_t mono_class_is_enum = nullptr;
mono_class_instance_size_t mono_class_instance_size = nullptr;
mono_object_get_size_t mono_object_get_size = nullptr;
mono_image_get_filename_t mono_image_get_filename = nullptr;
mono_assembly_load_from_full_t mono_assembly_load_from_full = nullptr;
mono_class_get_interfaces_t mono_class_get_interfaces = nullptr;
mono_assembly_close_t mono_assembly_close = nullptr;
mono_class_get_property_from_name_t mono_class_get_property_from_name = nullptr;
mono_class_get_method_from_name_t mono_class_get_method_from_name = nullptr;
mono_class_from_mono_type_t mono_class_from_mono_type = nullptr;
mono_domain_set_t mono_domain_set = nullptr;
mono_thread_push_appdomain_ref_t mono_thread_push_appdomain_ref = nullptr;
mono_thread_pop_appdomain_ref_t mono_thread_pop_appdomain_ref = nullptr;
mono_runtime_exec_main_t mono_runtime_exec_main = nullptr;
mono_get_corlib_t mono_get_corlib = nullptr;
mono_class_get_field_from_name_t mono_class_get_field_from_name = nullptr;
mono_class_get_flags_t mono_class_get_flags = nullptr;
mono_parse_default_optimizations_t mono_parse_default_optimizations = nullptr;
mono_set_defaults_t mono_set_defaults = nullptr;
mono_set_dirs_t mono_set_dirs = nullptr;
mono_jit_parse_options_t mono_jit_parse_options = nullptr;
mono_object_unbox_t mono_object_unbox = nullptr;
mono_custom_attrs_get_attr_t mono_custom_attrs_get_attr = nullptr;
mono_custom_attrs_has_attr_t mono_custom_attrs_has_attr = nullptr;
mono_custom_attrs_from_field_t mono_custom_attrs_from_field = nullptr;
mono_custom_attrs_from_method_t mono_custom_attrs_from_method = nullptr;
mono_custom_attrs_from_class_t mono_custom_attrs_from_class = nullptr;
mono_custom_attrs_free_t mono_custom_attrs_free = nullptr;
g_free_t g_free = nullptr;
mono_runtime_is_shutting_down_t mono_runtime_is_shutting_down = nullptr;
mono_object_get_virtual_method_t mono_object_get_virtual_method = nullptr;
mono_jit_info_get_code_start_t mono_jit_info_get_code_start = nullptr;
mono_jit_info_get_code_size_t mono_jit_info_get_code_size = nullptr;
mono_class_from_name_case_t mono_class_from_name_case = nullptr;
mono_class_get_nested_types_t mono_class_get_nested_types = nullptr;
mono_class_get_userdata_offset_t mono_class_get_userdata_offset = nullptr;
mono_class_get_userdata_t mono_class_get_userdata = nullptr;
mono_class_set_userdata_t mono_class_set_userdata = nullptr;
mono_set_signal_chaining_t mono_set_signal_chaining = nullptr;
// mono_unity_seh_handler_t mono_unity_seh_handler = nullptr;
mono_unity_set_unhandled_exception_handler_t mono_unity_set_unhandled_exception_handler = nullptr;
mono_runtime_invoke_array_t mono_runtime_invoke_array = nullptr;
mono_array_addr_with_size_t mono_array_addr_with_size = nullptr;
mono_string_to_utf16_t mono_string_to_utf16 = nullptr;
mono_field_get_parent_t mono_field_get_parent = nullptr;
mono_method_full_name_t mono_method_full_name = nullptr;
mono_object_isinst_t mono_object_isinst = nullptr;
mono_string_new_len_t mono_string_new_len = nullptr;
mono_string_from_utf16_t mono_string_from_utf16 = nullptr;
mono_get_exception_argument_null_t mono_get_exception_argument_null = nullptr;
mono_get_boolean_class_t mono_get_boolean_class = nullptr;
mono_get_byte_class_t mono_get_byte_class = nullptr;
mono_get_char_class_t mono_get_char_class = nullptr;
mono_get_int16_class_t mono_get_int16_class = nullptr;
mono_get_int64_class_t mono_get_int64_class = nullptr;
mono_get_single_class_t mono_get_single_class = nullptr;
mono_get_double_class_t mono_get_double_class = nullptr;
mono_class_is_generic_t mono_class_is_generic = nullptr;
mono_class_is_inflated_t mono_class_is_inflated = nullptr;
unity_mono_method_is_generic_t unity_mono_method_is_generic = nullptr;
unity_mono_method_is_inflated_t unity_mono_method_is_inflated = nullptr;
mono_is_debugger_attached_t mono_is_debugger_attached = nullptr;
mono_assembly_fill_assembly_name_t mono_assembly_fill_assembly_name = nullptr;
mono_stringify_assembly_name_t mono_stringify_assembly_name = nullptr;
mono_assembly_name_parse_t mono_assembly_name_parse = nullptr;
mono_assembly_loaded_t mono_assembly_loaded = nullptr;
mono_image_get_table_rows_t mono_image_get_table_rows = nullptr;
mono_class_get_t mono_class_get = nullptr;
mono_metadata_signature_equal_t mono_metadata_signature_equal = nullptr;
mono_gchandle_is_in_domain_t mono_gchandle_is_in_domain = nullptr;
mono_stack_walk_t mono_stack_walk = nullptr;
mono_pmip_t mono_pmip = nullptr;
mono_runtime_delegate_invoke_t mono_runtime_delegate_invoke = nullptr;
mono_jit_info_table_find_t mono_jit_info_table_find = nullptr;
mono_debug_lookup_source_location_t mono_debug_lookup_source_location = nullptr;
mono_debug_free_source_location_t mono_debug_free_source_location = nullptr;
mono_gc_wbarrier_generic_store_t mono_gc_wbarrier_generic_store = nullptr;
mono_class_enum_basetype_t mono_class_enum_basetype = nullptr;
mono_class_get_type_token_t mono_class_get_type_token = nullptr;
mono_class_get_rank_t mono_class_get_rank = nullptr;
mono_class_get_element_class_t mono_class_get_element_class = nullptr;
mono_unity_class_is_interface_t mono_unity_class_is_interface = nullptr;
mono_unity_class_is_abstract_t mono_unity_class_is_abstract = nullptr;
mono_array_element_size_t mono_array_element_size = nullptr;
mono_config_parse_t mono_config_parse = nullptr;
mono_set_break_policy_t mono_set_break_policy = nullptr;
mono_custom_attrs_construct_t mono_custom_attrs_construct = nullptr;
mono_custom_attrs_from_assembly_t mono_custom_attrs_from_assembly = nullptr;
mono_reflection_get_custom_attrs_by_type_t mono_reflection_get_custom_attrs_by_type = nullptr;
mono_loader_get_last_error_t mono_loader_get_last_error = nullptr;
mono_loader_error_prepare_exception_t mono_loader_error_prepare_exception = nullptr;
mono_dl_fallback_register_t mono_dl_fallback_register = nullptr;
mono_dl_fallback_unregister_t mono_dl_fallback_unregister = nullptr;
mono_unity_liveness_allocate_struct_t mono_unity_liveness_allocate_struct = nullptr;
mono_unity_liveness_stop_gc_world_t mono_unity_liveness_stop_gc_world = nullptr;
mono_unity_liveness_finalize_t mono_unity_liveness_finalize = nullptr;
mono_unity_liveness_start_gc_world_t mono_unity_liveness_start_gc_world = nullptr;
mono_unity_liveness_free_struct_t mono_unity_liveness_free_struct = nullptr;
mono_unity_liveness_calculation_begin_t mono_unity_liveness_calculation_begin = nullptr;
mono_unity_liveness_calculation_end_t mono_unity_liveness_calculation_end = nullptr;
mono_unity_liveness_calculation_from_root_t mono_unity_liveness_calculation_from_root = nullptr;
mono_unity_liveness_calculation_from_statics_t mono_unity_liveness_calculation_from_statics = nullptr;
mono_trace_set_level_string_t mono_trace_set_level_string = nullptr;
mono_trace_set_mask_string_t mono_trace_set_mask_string = nullptr;
mono_gc_get_used_size_t mono_gc_get_used_size = nullptr;
mono_gc_get_heap_size_t mono_gc_get_heap_size = nullptr;
mono_method_desc_search_in_class_t mono_method_desc_search_in_class = nullptr;
mono_method_desc_free_t mono_method_desc_free = nullptr;
mono_type_get_name_full_t mono_type_get_name_full = nullptr;
mono_unity_thread_clear_domain_fields_t mono_unity_thread_clear_domain_fields = nullptr;
// mono_unity_set_vprintf_func_t mono_unity_set_vprintf_func = nullptr;
mono_profiler_install_t mono_profiler_install = nullptr;
mono_profiler_set_events_t mono_profiler_set_events = nullptr;
mono_profiler_install_enter_leave_t mono_profiler_install_enter_leave = nullptr;
mono_profiler_install_gc_t mono_profiler_install_gc = nullptr;
mono_profiler_install_allocation_t mono_profiler_install_allocation = nullptr;
mono_profiler_install_jit_end_t mono_profiler_install_jit_end = nullptr;
mono_profiler_install_exception_t mono_profiler_install_exception = nullptr;
mono_profiler_install_thread_t mono_profiler_install_thread = nullptr;
mono_image_get_table_info_t mono_image_get_table_info=nullptr;
mono_table_info_get_rows_t mono_table_info_get_rows=nullptr;
void load_mono_functions_from_dll(HMODULE dll)
{
mono_table_info_get_rows=(mono_table_info_get_rows_t)(GetProcAddress(dll, "mono_table_info_get_rows"));
mono_image_get_table_info=(mono_image_get_table_info_t)(GetProcAddress(dll, "mono_image_get_table_info"));
mono_compile_method=(mono_compile_method_t)(GetProcAddress(dll, "mono_compile_method"));
mono_thread_suspend_all_other_threads = (mono_thread_suspend_all_other_threads_t)(GetProcAddress(dll, "mono_thread_suspend_all_other_threads"));
mono_thread_pool_cleanup = (mono_thread_pool_cleanup_t)(GetProcAddress(dll, "mono_thread_pool_cleanup"));
mono_threads_set_shutting_down = (mono_threads_set_shutting_down_t)(GetProcAddress(dll, "mono_threads_set_shutting_down"));
mono_runtime_set_shutting_down = (mono_runtime_set_shutting_down_t)(GetProcAddress(dll, "mono_runtime_set_shutting_down"));
mono_domain_finalize = (mono_domain_finalize_t)(GetProcAddress(dll, "mono_domain_finalize"));
mono_runtime_cleanup = (mono_runtime_cleanup_t)(GetProcAddress(dll, "mono_runtime_cleanup"));
mono_method_desc_new = (mono_method_desc_new_t)(GetProcAddress(dll, "mono_method_desc_new"));
mono_method_desc_search_in_image = (mono_method_desc_search_in_image_t)(GetProcAddress(dll, "mono_method_desc_search_in_image"));
mono_verifier_set_mode = (mono_verifier_set_mode_t)(GetProcAddress(dll, "mono_verifier_set_mode"));
mono_security_set_mode = (mono_security_set_mode_t)(GetProcAddress(dll, "mono_security_set_mode"));
mono_add_internal_call = (mono_add_internal_call_t)(GetProcAddress(dll, "mono_add_internal_call"));
mono_jit_cleanup = (mono_jit_cleanup_t)(GetProcAddress(dll, "mono_jit_cleanup"));
mono_jit_init = (mono_jit_init_t)(GetProcAddress(dll, "mono_jit_init"));
mono_jit_init_version = (mono_jit_init_version_t)(GetProcAddress(dll, "mono_jit_init_version"));
mono_jit_exec = (mono_jit_exec_t)(GetProcAddress(dll, "mono_jit_exec"));
mono_class_from_name = (mono_class_from_name_t)(GetProcAddress(dll, "mono_class_from_name"));
mono_domain_assembly_open = (mono_domain_assembly_open_t)(GetProcAddress(dll, "mono_domain_assembly_open"));
mono_domain_create_appdomain = (mono_domain_create_appdomain_t)(GetProcAddress(dll, "mono_domain_create_appdomain"));
mono_domain_unload = (mono_domain_unload_t)(GetProcAddress(dll, "mono_domain_unload"));
mono_object_new = (mono_object_new_t)(GetProcAddress(dll, "mono_object_new"));
mono_runtime_object_init = (mono_runtime_object_init_t)(GetProcAddress(dll, "mono_runtime_object_init"));
mono_runtime_invoke = (mono_runtime_invoke_t)(GetProcAddress(dll, "mono_runtime_invoke"));
mono_field_set_value = (mono_field_set_value_t)(GetProcAddress(dll, "mono_field_set_value"));
mono_field_get_value = (mono_field_get_value_t)(GetProcAddress(dll, "mono_field_get_value"));
mono_field_get_offset = (mono_field_get_offset_t)(GetProcAddress(dll, "mono_field_get_offset"));
mono_class_get_fields = (mono_class_get_fields_t)(GetProcAddress(dll, "mono_class_get_fields"));
mono_class_get_methods = (mono_class_get_methods_t)(GetProcAddress(dll, "mono_class_get_methods"));
mono_domain_get = (mono_domain_get_t)(GetProcAddress(dll, "mono_domain_get"));
mono_get_root_domain = (mono_get_root_domain_t)(GetProcAddress(dll, "mono_get_root_domain"));
mono_domain_get_id = (mono_domain_get_id_t)(GetProcAddress(dll, "mono_domain_get_id"));
mono_assembly_foreach = (mono_assembly_foreach_t)(GetProcAddress(dll, "mono_assembly_foreach"));
mono_image_close = (mono_image_close_t)(GetProcAddress(dll, "mono_image_close"));
mono_unity_socket_security_enabled_set = (mono_unity_socket_security_enabled_set_t)(GetProcAddress(dll, "mono_unity_socket_security_enabled_set"));
mono_image_get_name = (mono_image_get_name_t)(GetProcAddress(dll, "mono_image_get_name"));
mono_get_object_class = (mono_get_object_class_t)(GetProcAddress(dll, "mono_get_object_class"));
mono_set_commandline_arguments = (mono_set_commandline_arguments_t)(GetProcAddress(dll, "mono_set_commandline_arguments"));
mono_field_get_name = (mono_field_get_name_t)(GetProcAddress(dll, "mono_field_get_name"));
mono_field_get_type = (mono_field_get_type_t)(GetProcAddress(dll, "mono_field_get_type"));
mono_type_get_type = (mono_type_get_type_t)(GetProcAddress(dll, "mono_type_get_type"));
mono_method_get_name = (mono_method_get_name_t)(GetProcAddress(dll, "mono_method_get_name"));
mono_assembly_get_image = (mono_assembly_get_image_t)(GetProcAddress(dll, "mono_assembly_get_image"));
mono_method_get_class = (mono_method_get_class_t)(GetProcAddress(dll, "mono_method_get_class"));
mono_object_get_class = (mono_object_get_class_t)(GetProcAddress(dll, "mono_object_get_class"));
mono_class_is_valuetype = (mono_class_is_valuetype_t)(GetProcAddress(dll, "mono_class_is_valuetype"));
mono_signature_get_param_count = (mono_signature_get_param_count_t)(GetProcAddress(dll, "mono_signature_get_param_count"));
mono_string_to_utf8 = (mono_string_to_utf8_t)(GetProcAddress(dll, "mono_string_to_utf8"));
mono_string_new_wrapper = (mono_string_new_wrapper_t)(GetProcAddress(dll, "mono_string_new_wrapper"));
mono_class_get_parent = (mono_class_get_parent_t)(GetProcAddress(dll, "mono_class_get_parent"));
mono_class_get_namespace = (mono_class_get_namespace_t)(GetProcAddress(dll, "mono_class_get_namespace"));
mono_class_is_subclass_of = (mono_class_is_subclass_of_t)(GetProcAddress(dll, "mono_class_is_subclass_of"));
mono_class_get_name = (mono_class_get_name_t)(GetProcAddress(dll, "mono_class_get_name"));
mono_type_get_name = (mono_type_get_name_t)(GetProcAddress(dll, "mono_type_get_name"));
mono_type_get_class = (mono_type_get_class_t)(GetProcAddress(dll, "mono_type_get_class"));
mono_exception_from_name_msg = (mono_exception_from_name_msg_t)(GetProcAddress(dll, "mono_exception_from_name_msg"));
mono_raise_exception = (mono_raise_exception_t)(GetProcAddress(dll, "mono_raise_exception"));
mono_get_exception_class = (mono_get_exception_class_t)(GetProcAddress(dll, "mono_get_exception_class"));
mono_get_array_class = (mono_get_array_class_t)(GetProcAddress(dll, "mono_get_array_class"));
mono_get_string_class = (mono_get_string_class_t)(GetProcAddress(dll, "mono_get_string_class"));
mono_get_int32_class = (mono_get_int32_class_t)(GetProcAddress(dll, "mono_get_int32_class"));
mono_array_new = (mono_array_new_t)(GetProcAddress(dll, "mono_array_new"));
mono_array_new_full = (mono_array_new_full_t)(GetProcAddress(dll, "mono_array_new_full"));
mono_array_class_get = (mono_array_class_get_t)(GetProcAddress(dll, "mono_array_class_get"));
mono_class_array_element_size = (mono_class_array_element_size_t)(GetProcAddress(dll, "mono_class_array_element_size"));
mono_type_get_object = (mono_type_get_object_t)(GetProcAddress(dll, "mono_type_get_object"));
mono_thread_attach = (mono_thread_attach_t)(GetProcAddress(dll, "mono_thread_attach"));
mono_thread_detach = (mono_thread_detach_t)(GetProcAddress(dll, "mono_thread_detach"));
mono_thread_exit = (mono_thread_exit_t)(GetProcAddress(dll, "mono_thread_exit"));
mono_thread_current = (mono_thread_current_t)(GetProcAddress(dll, "mono_thread_current"));
mono_thread_set_main = (mono_thread_set_main_t)(GetProcAddress(dll, "mono_thread_set_main"));
mono_set_find_plugin_callback = (mono_set_find_plugin_callback_t)(GetProcAddress(dll, "mono_set_find_plugin_callback"));
mono_security_enable_core_clr = (mono_security_enable_core_clr_t)(GetProcAddress(dll, "mono_security_enable_core_clr"));
mono_security_set_core_clr_platform_callback = (mono_security_set_core_clr_platform_callback_t)(GetProcAddress(dll, "mono_security_set_core_clr_platform_callback"));
mono_runtime_unhandled_exception_policy_get = (mono_runtime_unhandled_exception_policy_get_t)(GetProcAddress(dll, "mono_runtime_unhandled_exception_policy_get"));
mono_runtime_unhandled_exception_policy_set = (mono_runtime_unhandled_exception_policy_set_t)(GetProcAddress(dll, "mono_runtime_unhandled_exception_policy_set"));
mono_class_get_nesting_type = (mono_class_get_nesting_type_t)(GetProcAddress(dll, "mono_class_get_nesting_type"));
mono_class_vtable = (mono_class_vtable_t)(GetProcAddress(dll, "mono_class_vtable"));
mono_method_get_object = (mono_method_get_object_t)(GetProcAddress(dll, "mono_method_get_object"));
mono_method_signature = (mono_method_signature_t)(GetProcAddress(dll, "mono_method_signature"));
mono_signature_get_params = (mono_signature_get_params_t)(GetProcAddress(dll, "mono_signature_get_params"));
mono_signature_get_return_type = (mono_signature_get_return_type_t)(GetProcAddress(dll, "mono_signature_get_return_type"));
mono_class_get_type = (mono_class_get_type_t)(GetProcAddress(dll, "mono_class_get_type"));
mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded = (mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded_t)(GetProcAddress(dll, "mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded"));
mono_debug_init = (mono_debug_init_t)(GetProcAddress(dll, "mono_debug_init"));
mono_debug_open_image_from_memory = (mono_debug_open_image_from_memory_t)(GetProcAddress(dll, "mono_debug_open_image_from_memory"));
mono_field_get_flags = (mono_field_get_flags_t)(GetProcAddress(dll, "mono_field_get_flags"));
mono_image_open_from_data_full = (mono_image_open_from_data_full_t)(GetProcAddress(dll, "mono_image_open_from_data_full"));
mono_image_open_from_data_with_name = (mono_image_open_from_data_with_name_t)(GetProcAddress(dll, "mono_image_open_from_data_with_name"));
mono_assembly_load_from = (mono_assembly_load_from_t)(GetProcAddress(dll, "mono_assembly_load_from"));
mono_value_box = (mono_value_box_t)(GetProcAddress(dll, "mono_value_box"));
mono_class_get_image = (mono_class_get_image_t)(GetProcAddress(dll, "mono_class_get_image"));
mono_signature_is_instance = (mono_signature_is_instance_t)(GetProcAddress(dll, "mono_signature_is_instance"));
mono_method_get_last_managed = (mono_method_get_last_managed_t)(GetProcAddress(dll, "mono_method_get_last_managed"));
mono_get_enum_class = (mono_get_enum_class_t)(GetProcAddress(dll, "mono_get_enum_class"));
mono_class_get_byref_type = (mono_class_get_byref_type_t)(GetProcAddress(dll, "mono_class_get_byref_type"));
mono_field_static_get_value = (mono_field_static_get_value_t)(GetProcAddress(dll, "mono_field_static_get_value"));
mono_unity_set_embeddinghostname = (mono_unity_set_embeddinghostname_t)(GetProcAddress(dll, "mono_unity_set_embeddinghostname"));
mono_set_assemblies_path = (mono_set_assemblies_path_t)(GetProcAddress(dll, "mono_set_assemblies_path"));
mono_gchandle_new = (mono_gchandle_new_t)(GetProcAddress(dll, "mono_gchandle_new"));
mono_gchandle_get_target = (mono_gchandle_get_target_t)(GetProcAddress(dll, "mono_gchandle_get_target"));
mono_gchandle_new_weakref = (mono_gchandle_new_weakref_t)(GetProcAddress(dll, "mono_gchandle_new_weakref"));
mono_assembly_get_object = (mono_assembly_get_object_t)(GetProcAddress(dll, "mono_assembly_get_object"));
mono_gchandle_free = (mono_gchandle_free_t)(GetProcAddress(dll, "mono_gchandle_free"));
mono_class_get_properties = (mono_class_get_properties_t)(GetProcAddress(dll, "mono_class_get_properties"));
mono_property_get_get_method = (mono_property_get_get_method_t)(GetProcAddress(dll, "mono_property_get_get_method"));
mono_object_new_alloc_specific = (mono_object_new_alloc_specific_t)(GetProcAddress(dll, "mono_object_new_alloc_specific"));
mono_object_new_specific = (mono_object_new_specific_t)(GetProcAddress(dll, "mono_object_new_specific"));
mono_gc_collect = (mono_gc_collect_t)(GetProcAddress(dll, "mono_gc_collect"));
mono_gc_max_generation = (mono_gc_max_generation_t)(GetProcAddress(dll, "mono_gc_max_generation"));
mono_image_get_assembly = (mono_image_get_assembly_t)(GetProcAddress(dll, "mono_image_get_assembly"));
mono_assembly_open = (mono_assembly_open_t)(GetProcAddress(dll, "mono_assembly_open"));
mono_class_is_enum = (mono_class_is_enum_t)(GetProcAddress(dll, "mono_class_is_enum"));
mono_class_instance_size = (mono_class_instance_size_t)(GetProcAddress(dll, "mono_class_instance_size"));
mono_object_get_size = (mono_object_get_size_t)(GetProcAddress(dll, "mono_object_get_size"));
mono_image_get_filename = (mono_image_get_filename_t)(GetProcAddress(dll, "mono_image_get_filename"));
mono_assembly_load_from_full = (mono_assembly_load_from_full_t)(GetProcAddress(dll, "mono_assembly_load_from_full"));
mono_class_get_interfaces = (mono_class_get_interfaces_t)(GetProcAddress(dll, "mono_class_get_interfaces"));
mono_assembly_close = (mono_assembly_close_t)(GetProcAddress(dll, "mono_assembly_close"));
mono_class_get_property_from_name = (mono_class_get_property_from_name_t)(GetProcAddress(dll, "mono_class_get_property_from_name"));
mono_class_get_method_from_name = (mono_class_get_method_from_name_t)(GetProcAddress(dll, "mono_class_get_method_from_name"));
mono_class_from_mono_type = (mono_class_from_mono_type_t)(GetProcAddress(dll, "mono_class_from_mono_type"));
mono_domain_set = (mono_domain_set_t)(GetProcAddress(dll, "mono_domain_set"));
mono_thread_push_appdomain_ref = (mono_thread_push_appdomain_ref_t)(GetProcAddress(dll, "mono_thread_push_appdomain_ref"));
mono_thread_pop_appdomain_ref = (mono_thread_pop_appdomain_ref_t)(GetProcAddress(dll, "mono_thread_pop_appdomain_ref"));
mono_runtime_exec_main = (mono_runtime_exec_main_t)(GetProcAddress(dll, "mono_runtime_exec_main"));
mono_get_corlib = (mono_get_corlib_t)(GetProcAddress(dll, "mono_get_corlib"));
mono_class_get_field_from_name = (mono_class_get_field_from_name_t)(GetProcAddress(dll, "mono_class_get_field_from_name"));
mono_class_get_flags = (mono_class_get_flags_t)(GetProcAddress(dll, "mono_class_get_flags"));
mono_parse_default_optimizations = (mono_parse_default_optimizations_t)(GetProcAddress(dll, "mono_parse_default_optimizations"));
mono_set_defaults = (mono_set_defaults_t)(GetProcAddress(dll, "mono_set_defaults"));
mono_set_dirs = (mono_set_dirs_t)(GetProcAddress(dll, "mono_set_dirs"));
mono_jit_parse_options = (mono_jit_parse_options_t)(GetProcAddress(dll, "mono_jit_parse_options"));
mono_object_unbox = (mono_object_unbox_t)(GetProcAddress(dll, "mono_object_unbox"));
mono_custom_attrs_get_attr = (mono_custom_attrs_get_attr_t)(GetProcAddress(dll, "mono_custom_attrs_get_attr"));
mono_custom_attrs_has_attr = (mono_custom_attrs_has_attr_t)(GetProcAddress(dll, "mono_custom_attrs_has_attr"));
mono_custom_attrs_from_field = (mono_custom_attrs_from_field_t)(GetProcAddress(dll, "mono_custom_attrs_from_field"));
mono_custom_attrs_from_method = (mono_custom_attrs_from_method_t)(GetProcAddress(dll, "mono_custom_attrs_from_method"));
mono_custom_attrs_from_class = (mono_custom_attrs_from_class_t)(GetProcAddress(dll, "mono_custom_attrs_from_class"));
mono_custom_attrs_free = (mono_custom_attrs_free_t)(GetProcAddress(dll, "mono_custom_attrs_free"));
g_free = (g_free_t)(GetProcAddress(dll, "g_free"));
mono_runtime_is_shutting_down = (mono_runtime_is_shutting_down_t)(GetProcAddress(dll, "mono_runtime_is_shutting_down"));
mono_object_get_virtual_method = (mono_object_get_virtual_method_t)(GetProcAddress(dll, "mono_object_get_virtual_method"));
mono_jit_info_get_code_start = (mono_jit_info_get_code_start_t)(GetProcAddress(dll, "mono_jit_info_get_code_start"));
mono_jit_info_get_code_size = (mono_jit_info_get_code_size_t)(GetProcAddress(dll, "mono_jit_info_get_code_size"));
mono_class_from_name_case = (mono_class_from_name_case_t)(GetProcAddress(dll, "mono_class_from_name_case"));
mono_class_get_nested_types = (mono_class_get_nested_types_t)(GetProcAddress(dll, "mono_class_get_nested_types"));
mono_class_get_userdata_offset = (mono_class_get_userdata_offset_t)(GetProcAddress(dll, "mono_class_get_userdata_offset"));
mono_class_get_userdata = (mono_class_get_userdata_t)(GetProcAddress(dll, "mono_class_get_userdata"));
mono_class_set_userdata = (mono_class_set_userdata_t)(GetProcAddress(dll, "mono_class_set_userdata"));
mono_set_signal_chaining = (mono_set_signal_chaining_t)(GetProcAddress(dll, "mono_set_signal_chaining"));
// mono_unity_seh_handler = (mono_unity_seh_handler_t)(GetProcAddress(dll, "mono_unity_seh_handler"));
mono_unity_set_unhandled_exception_handler = (mono_unity_set_unhandled_exception_handler_t)(GetProcAddress(dll, "mono_unity_set_unhandled_exception_handler"));
mono_runtime_invoke_array = (mono_runtime_invoke_array_t)(GetProcAddress(dll, "mono_runtime_invoke_array"));
mono_array_addr_with_size = (mono_array_addr_with_size_t)(GetProcAddress(dll, "mono_array_addr_with_size"));
mono_string_to_utf16 = (mono_string_to_utf16_t)(GetProcAddress(dll, "mono_string_to_utf16"));
mono_field_get_parent = (mono_field_get_parent_t)(GetProcAddress(dll, "mono_field_get_parent"));
mono_method_full_name = (mono_method_full_name_t)(GetProcAddress(dll, "mono_method_full_name"));
mono_object_isinst = (mono_object_isinst_t)(GetProcAddress(dll, "mono_object_isinst"));
mono_string_new_len = (mono_string_new_len_t)(GetProcAddress(dll, "mono_string_new_len"));
mono_string_from_utf16 = (mono_string_from_utf16_t)(GetProcAddress(dll, "mono_string_from_utf16"));
mono_get_exception_argument_null = (mono_get_exception_argument_null_t)(GetProcAddress(dll, "mono_get_exception_argument_null"));
mono_get_boolean_class = (mono_get_boolean_class_t)(GetProcAddress(dll, "mono_get_boolean_class"));
mono_get_byte_class = (mono_get_byte_class_t)(GetProcAddress(dll, "mono_get_byte_class"));
mono_get_char_class = (mono_get_char_class_t)(GetProcAddress(dll, "mono_get_char_class"));
mono_get_int16_class = (mono_get_int16_class_t)(GetProcAddress(dll, "mono_get_int16_class"));
mono_get_int64_class = (mono_get_int64_class_t)(GetProcAddress(dll, "mono_get_int64_class"));
mono_get_single_class = (mono_get_single_class_t)(GetProcAddress(dll, "mono_get_single_class"));
mono_get_double_class = (mono_get_double_class_t)(GetProcAddress(dll, "mono_get_double_class"));
mono_class_is_generic = (mono_class_is_generic_t)(GetProcAddress(dll, "mono_class_is_generic"));
mono_class_is_inflated = (mono_class_is_inflated_t)(GetProcAddress(dll, "mono_class_is_inflated"));
unity_mono_method_is_generic = (unity_mono_method_is_generic_t)(GetProcAddress(dll, "unity_mono_method_is_generic"));
unity_mono_method_is_inflated = (unity_mono_method_is_inflated_t)(GetProcAddress(dll, "unity_mono_method_is_inflated"));
mono_is_debugger_attached = (mono_is_debugger_attached_t)(GetProcAddress(dll, "mono_is_debugger_attached"));
mono_assembly_fill_assembly_name = (mono_assembly_fill_assembly_name_t)(GetProcAddress(dll, "mono_assembly_fill_assembly_name"));
mono_stringify_assembly_name = (mono_stringify_assembly_name_t)(GetProcAddress(dll, "mono_stringify_assembly_name"));
mono_assembly_name_parse = (mono_assembly_name_parse_t)(GetProcAddress(dll, "mono_assembly_name_parse"));
mono_assembly_loaded = (mono_assembly_loaded_t)(GetProcAddress(dll, "mono_assembly_loaded"));
mono_image_get_table_rows = (mono_image_get_table_rows_t)(GetProcAddress(dll, "mono_image_get_table_rows"));
mono_class_get = (mono_class_get_t)(GetProcAddress(dll, "mono_class_get"));
mono_metadata_signature_equal = (mono_metadata_signature_equal_t)(GetProcAddress(dll, "mono_metadata_signature_equal"));
mono_gchandle_is_in_domain = (mono_gchandle_is_in_domain_t)(GetProcAddress(dll, "mono_gchandle_is_in_domain"));
mono_stack_walk = (mono_stack_walk_t)(GetProcAddress(dll, "mono_stack_walk"));
mono_pmip = (mono_pmip_t)(GetProcAddress(dll, "mono_pmip"));
mono_runtime_delegate_invoke = (mono_runtime_delegate_invoke_t)(GetProcAddress(dll, "mono_runtime_delegate_invoke"));
mono_jit_info_table_find = (mono_jit_info_table_find_t)(GetProcAddress(dll, "mono_jit_info_table_find"));
mono_debug_lookup_source_location = (mono_debug_lookup_source_location_t)(GetProcAddress(dll, "mono_debug_lookup_source_location"));
mono_debug_free_source_location = (mono_debug_free_source_location_t)(GetProcAddress(dll, "mono_debug_free_source_location"));
mono_gc_wbarrier_generic_store = (mono_gc_wbarrier_generic_store_t)(GetProcAddress(dll, "mono_gc_wbarrier_generic_store"));
mono_class_enum_basetype = (mono_class_enum_basetype_t)(GetProcAddress(dll, "mono_class_enum_basetype"));
mono_class_get_type_token = (mono_class_get_type_token_t)(GetProcAddress(dll, "mono_class_get_type_token"));
mono_class_get_rank = (mono_class_get_rank_t)(GetProcAddress(dll, "mono_class_get_rank"));
mono_class_get_element_class = (mono_class_get_element_class_t)(GetProcAddress(dll, "mono_class_get_element_class"));
mono_unity_class_is_interface = (mono_unity_class_is_interface_t)(GetProcAddress(dll, "mono_unity_class_is_interface"));
mono_unity_class_is_abstract = (mono_unity_class_is_abstract_t)(GetProcAddress(dll, "mono_unity_class_is_abstract"));
mono_array_element_size = (mono_array_element_size_t)(GetProcAddress(dll, "mono_array_element_size"));
mono_config_parse = (mono_config_parse_t)(GetProcAddress(dll, "mono_config_parse"));
mono_set_break_policy = (mono_set_break_policy_t)(GetProcAddress(dll, "mono_set_break_policy"));
mono_custom_attrs_construct = (mono_custom_attrs_construct_t)(GetProcAddress(dll, "mono_custom_attrs_construct"));
mono_custom_attrs_from_assembly = (mono_custom_attrs_from_assembly_t)(GetProcAddress(dll, "mono_custom_attrs_from_assembly"));
mono_reflection_get_custom_attrs_by_type = (mono_reflection_get_custom_attrs_by_type_t)(GetProcAddress(dll, "mono_reflection_get_custom_attrs_by_type"));
mono_loader_get_last_error = (mono_loader_get_last_error_t)(GetProcAddress(dll, "mono_loader_get_last_error"));
mono_loader_error_prepare_exception = (mono_loader_error_prepare_exception_t)(GetProcAddress(dll, "mono_loader_error_prepare_exception"));
mono_dl_fallback_register = (mono_dl_fallback_register_t)(GetProcAddress(dll, "mono_dl_fallback_register"));
mono_dl_fallback_unregister = (mono_dl_fallback_unregister_t)(GetProcAddress(dll, "mono_dl_fallback_unregister"));
mono_unity_liveness_allocate_struct = (mono_unity_liveness_allocate_struct_t)(GetProcAddress(dll, "mono_unity_liveness_allocate_struct"));
mono_unity_liveness_stop_gc_world = (mono_unity_liveness_stop_gc_world_t)(GetProcAddress(dll, "mono_unity_liveness_stop_gc_world"));
mono_unity_liveness_finalize = (mono_unity_liveness_finalize_t)(GetProcAddress(dll, "mono_unity_liveness_finalize"));
mono_unity_liveness_start_gc_world = (mono_unity_liveness_start_gc_world_t)(GetProcAddress(dll, "mono_unity_liveness_start_gc_world"));
mono_unity_liveness_free_struct = (mono_unity_liveness_free_struct_t)(GetProcAddress(dll, "mono_unity_liveness_free_struct"));
mono_unity_liveness_calculation_begin = (mono_unity_liveness_calculation_begin_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_begin"));
mono_unity_liveness_calculation_end = (mono_unity_liveness_calculation_end_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_end"));
mono_unity_liveness_calculation_from_root = (mono_unity_liveness_calculation_from_root_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_from_root"));
mono_unity_liveness_calculation_from_statics = (mono_unity_liveness_calculation_from_statics_t)(GetProcAddress(dll, "mono_unity_liveness_calculation_from_statics"));
mono_trace_set_level_string = (mono_trace_set_level_string_t)(GetProcAddress(dll, "mono_trace_set_level_string"));
mono_trace_set_mask_string = (mono_trace_set_mask_string_t)(GetProcAddress(dll, "mono_trace_set_mask_string"));
mono_gc_get_used_size = (mono_gc_get_used_size_t)(GetProcAddress(dll, "mono_gc_get_used_size"));
mono_gc_get_heap_size = (mono_gc_get_heap_size_t)(GetProcAddress(dll, "mono_gc_get_heap_size"));
mono_method_desc_search_in_class = (mono_method_desc_search_in_class_t)(GetProcAddress(dll, "mono_method_desc_search_in_class"));
mono_method_desc_free = (mono_method_desc_free_t)(GetProcAddress(dll, "mono_method_desc_free"));
mono_type_get_name_full = (mono_type_get_name_full_t)(GetProcAddress(dll, "mono_type_get_name_full"));
mono_unity_thread_clear_domain_fields = (mono_unity_thread_clear_domain_fields_t)(GetProcAddress(dll, "mono_unity_thread_clear_domain_fields"));
// mono_unity_set_vprintf_func = (mono_unity_set_vprintf_func_t)(GetProcAddress(dll, "mono_unity_set_vprintf_func"));
mono_profiler_install = (mono_profiler_install_t)(GetProcAddress(dll, "mono_profiler_install"));
mono_profiler_set_events = (mono_profiler_set_events_t)(GetProcAddress(dll, "mono_profiler_set_events"));
mono_profiler_install_enter_leave = (mono_profiler_install_enter_leave_t)(GetProcAddress(dll, "mono_profiler_install_enter_leave"));
mono_profiler_install_gc = (mono_profiler_install_gc_t)(GetProcAddress(dll, "mono_profiler_install_gc"));
mono_profiler_install_allocation = (mono_profiler_install_allocation_t)(GetProcAddress(dll, "mono_profiler_install_allocation"));
mono_profiler_install_jit_end = (mono_profiler_install_jit_end_t)(GetProcAddress(dll, "mono_profiler_install_jit_end"));
mono_profiler_install_exception = (mono_profiler_install_exception_t)(GetProcAddress(dll, "mono_profiler_install_exception"));
mono_profiler_install_thread = (mono_profiler_install_thread_t)(GetProcAddress(dll, "mono_profiler_install_thread"));
}
namespace{ namespace{
void MonoCallBack(void* assembly, void* userData) {
void MonoCallBack(void* assembly, void* userData) {
auto Image=(SafeFptr(mono_assembly_get_image))((MonoAssembly*)assembly); auto Image=(SafeFptr(mono_assembly_get_image))((MonoAssembly*)assembly);
if(!Image)return; if(!Image)return;
auto st=reinterpret_cast<std::vector<MonoImage*>*>(userData); auto st=reinterpret_cast<std::vector<MonoImage*>*>(userData);
st->push_back(Image); st->push_back(Image);
} }
std::vector<MonoImage*>mono_loop_images(){ std::vector<MonoImage*>mono_loop_images(){
std::vector<MonoImage*>images; std::vector<MonoImage*>images;
(SafeFptr(mono_assembly_foreach))(MonoCallBack,(void*)&images); (SafeFptr(mono_assembly_foreach))(MonoCallBack,(void*)&images);
return images; return images;
} }
MonoClass* mono_findklassby_ass_namespace(std::vector<MonoImage*>& images,const char *_dll, const char *_namespace,const char *_class,bool strict){ MonoClass* mono_findklassby_ass_namespace(std::vector<MonoImage*>& images,const char *_dll, const char *_namespace,const char *_class,bool strict){
MonoClass* maybe=NULL; MonoClass* maybe=NULL;
for(auto Image:images){ for(auto Image:images){
@ -494,12 +27,12 @@ MonoClass* mono_findklassby_ass_namespace(std::vector<MonoImage*>& images,const
} }
if(strict)return NULL; if(strict)return NULL;
return maybe; return maybe;
} }
std::vector<MonoClass*> mono_findklassby_class(std::vector<MonoImage*>& images,const char *_namespace,const char *_class){ std::vector<MonoClass*> mono_findklassby_class(std::vector<MonoImage*>& images,const char *_namespace,const char *_class){
std::vector<MonoClass*>maybes; std::vector<MonoClass*>maybes;
for(auto image:images){ for(auto image:images){
auto _1=(SafeFptr(mono_image_get_table_info))((void*)image,MONO_TABLE_TYPEDEF); auto _1=(SafeFptr(mono_image_get_table_info))(image,MONO_TABLE_TYPEDEF);
if(!_1)continue; if(!_1)continue;
auto tdefcount=(SafeFptr(mono_table_info_get_rows))(_1); auto tdefcount=(SafeFptr(mono_table_info_get_rows))(_1);
if(!tdefcount)continue; if(!tdefcount)continue;
@ -519,23 +52,23 @@ std::vector<MonoClass*> mono_findklassby_class(std::vector<MonoImage*>& images,c
} }
} }
return maybes; return maybes;
} }
void tryprintimage(MonoClass* klass){ void tryprintimage(MonoClass* klass){
auto image=(SafeFptr(mono_class_get_image))(klass); auto image=(SafeFptr(mono_class_get_image))(klass);
if(!image)return; if(!image)return;
auto imagen=(SafeFptr(mono_image_get_name))(image); auto imagen=(SafeFptr(mono_image_get_name))(image);
auto names=(SafeFptr(mono_class_get_namespace))(klass); auto names=(SafeFptr(mono_class_get_namespace))(klass);
if(imagen&&names) if(imagen&&names)
ConsoleOutput("%s:%s",imagen,names); ConsoleOutput("%s:%s",imagen,names);
} }
uintptr_t getmethodofklass(MonoClass* klass,const char* name, int argsCount){ uintptr_t getmethodofklass(MonoClass* klass,const char* name, int argsCount){
if(!klass)return NULL; if(!klass)return NULL;
auto MonoClassMethod = (SafeFptr(mono_class_get_method_from_name))(klass, name, argsCount); auto MonoClassMethod = (SafeFptr(mono_class_get_method_from_name))(klass, name, argsCount);
if(!MonoClassMethod)return NULL; if(!MonoClassMethod)return NULL;
tryprintimage(klass); tryprintimage(klass);
return (uintptr_t)(SafeFptr(mono_compile_method))((uintptr_t)MonoClassMethod); return (uintptr_t)(SafeFptr(mono_compile_method))(MonoClassMethod);
} }
struct AutoThread{ struct AutoThread{
MonoThread *thread=NULL; MonoThread *thread=NULL;
AutoThread(){ AutoThread(){
auto _root=(SafeFptr(mono_get_root_domain))(); auto _root=(SafeFptr(mono_get_root_domain))();
@ -546,9 +79,140 @@ struct AutoThread{
if(!thread)return; if(!thread)return;
(SafeFptr(mono_thread_detach))(thread); (SafeFptr(mono_thread_detach))(thread);
} }
}; };
} }
uintptr_t getmonofunctionptr(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCount,bool strict) { void monofunctions::init(HMODULE game_module)
{
RESOLVE_IMPORT(mono_string_chars);
RESOLVE_IMPORT(mono_string_length);
RESOLVE_IMPORT(mono_table_info_get_rows);
RESOLVE_IMPORT(mono_image_get_table_info);
RESOLVE_IMPORT(mono_compile_method);
RESOLVE_IMPORT(mono_class_from_name );
RESOLVE_IMPORT(mono_domain_get );
RESOLVE_IMPORT(mono_get_root_domain );
RESOLVE_IMPORT(mono_assembly_foreach );
RESOLVE_IMPORT(mono_image_get_name );
RESOLVE_IMPORT(mono_assembly_get_image );
RESOLVE_IMPORT(mono_class_is_valuetype );
RESOLVE_IMPORT(mono_signature_get_param_count );
RESOLVE_IMPORT(mono_string_to_utf8 );
RESOLVE_IMPORT(mono_string_new_wrapper );
RESOLVE_IMPORT(mono_class_get_parent );
RESOLVE_IMPORT(mono_class_get_namespace );
RESOLVE_IMPORT(mono_class_is_subclass_of );
RESOLVE_IMPORT(mono_class_get_name );
RESOLVE_IMPORT(mono_type_get_name );
RESOLVE_IMPORT(mono_type_get_class );
RESOLVE_IMPORT(mono_exception_from_name_msg );
RESOLVE_IMPORT(mono_raise_exception );
RESOLVE_IMPORT(mono_get_exception_class );
RESOLVE_IMPORT(mono_get_array_class );
RESOLVE_IMPORT(mono_get_string_class );
RESOLVE_IMPORT(mono_get_int32_class );
RESOLVE_IMPORT(mono_array_new );
RESOLVE_IMPORT(mono_array_new_full );
RESOLVE_IMPORT(mono_array_class_get );
RESOLVE_IMPORT(mono_class_array_element_size );
RESOLVE_IMPORT(mono_type_get_object );
RESOLVE_IMPORT(mono_thread_attach );
RESOLVE_IMPORT(mono_thread_detach );
RESOLVE_IMPORT(mono_thread_exit );
RESOLVE_IMPORT(mono_thread_current );
RESOLVE_IMPORT(mono_thread_set_main );
RESOLVE_IMPORT(mono_set_find_plugin_callback );
RESOLVE_IMPORT(mono_security_enable_core_clr );
RESOLVE_IMPORT(mono_security_set_core_clr_platform_callback );
RESOLVE_IMPORT(mono_runtime_unhandled_exception_policy_get );
RESOLVE_IMPORT(mono_runtime_unhandled_exception_policy_set );
RESOLVE_IMPORT(mono_class_get_nesting_type );
RESOLVE_IMPORT(mono_class_vtable );
RESOLVE_IMPORT(mono_method_get_object );
RESOLVE_IMPORT(mono_method_signature );
RESOLVE_IMPORT(mono_signature_get_params );
RESOLVE_IMPORT(mono_signature_get_return_type );
RESOLVE_IMPORT(mono_class_get_type );
RESOLVE_IMPORT(mono_set_ignore_version_and_key_when_finding_assemblies_already_loaded );
RESOLVE_IMPORT(mono_debug_init );
RESOLVE_IMPORT(mono_debug_open_image_from_memory );
RESOLVE_IMPORT(mono_field_get_flags );
RESOLVE_IMPORT(mono_image_open_from_data_full );
RESOLVE_IMPORT(mono_image_open_from_data_with_name );
RESOLVE_IMPORT(mono_assembly_load_from );
RESOLVE_IMPORT(mono_value_box );
RESOLVE_IMPORT(mono_class_get_image );
RESOLVE_IMPORT(mono_signature_is_instance );
RESOLVE_IMPORT(mono_method_get_last_managed );
RESOLVE_IMPORT(mono_get_enum_class );
RESOLVE_IMPORT(mono_class_get_byref_type );
RESOLVE_IMPORT(mono_field_static_get_value );
RESOLVE_IMPORT(mono_unity_set_embeddinghostname );
RESOLVE_IMPORT(mono_set_assemblies_path );
RESOLVE_IMPORT(mono_gchandle_new );
RESOLVE_IMPORT(mono_gchandle_get_target );
RESOLVE_IMPORT(mono_gchandle_new_weakref );
RESOLVE_IMPORT(mono_assembly_get_object );
RESOLVE_IMPORT(mono_gchandle_free );
RESOLVE_IMPORT(mono_class_get_properties );
RESOLVE_IMPORT(mono_property_get_get_method );
RESOLVE_IMPORT(mono_object_new_alloc_specific );
RESOLVE_IMPORT(mono_object_new_specific );
RESOLVE_IMPORT(mono_gc_collect );
RESOLVE_IMPORT(mono_gc_max_generation );
RESOLVE_IMPORT(mono_image_get_assembly );
RESOLVE_IMPORT(mono_assembly_open );
RESOLVE_IMPORT(mono_class_is_enum );
RESOLVE_IMPORT(mono_class_instance_size );
RESOLVE_IMPORT(mono_object_get_size );
RESOLVE_IMPORT(mono_image_get_filename );
RESOLVE_IMPORT(mono_assembly_load_from_full );
RESOLVE_IMPORT(mono_class_get_interfaces );
RESOLVE_IMPORT(mono_assembly_close );
RESOLVE_IMPORT(mono_class_get_property_from_name );
RESOLVE_IMPORT(mono_class_get_method_from_name );
RESOLVE_IMPORT(mono_class_from_mono_type );
RESOLVE_IMPORT(mono_domain_set );
RESOLVE_IMPORT(mono_thread_push_appdomain_ref );
RESOLVE_IMPORT(mono_thread_pop_appdomain_ref );
RESOLVE_IMPORT(mono_runtime_exec_main );
RESOLVE_IMPORT(mono_get_corlib );
RESOLVE_IMPORT(mono_class_get_field_from_name );
RESOLVE_IMPORT(mono_class_get_flags );
RESOLVE_IMPORT(mono_parse_default_optimizations );
RESOLVE_IMPORT(mono_set_defaults );
RESOLVE_IMPORT(mono_set_dirs );
RESOLVE_IMPORT(mono_jit_parse_options );
RESOLVE_IMPORT(mono_object_unbox );
RESOLVE_IMPORT(mono_custom_attrs_get_attr );
RESOLVE_IMPORT(mono_custom_attrs_has_attr );
RESOLVE_IMPORT(mono_custom_attrs_from_field );
RESOLVE_IMPORT(mono_custom_attrs_from_method );
RESOLVE_IMPORT(mono_custom_attrs_from_class );
RESOLVE_IMPORT(mono_custom_attrs_free );
RESOLVE_IMPORT(g_free );
RESOLVE_IMPORT(mono_runtime_is_shutting_down );
RESOLVE_IMPORT(mono_object_get_virtual_method );
RESOLVE_IMPORT(mono_jit_info_get_code_start );
RESOLVE_IMPORT(mono_jit_info_get_code_size );
RESOLVE_IMPORT(mono_class_from_name_case );
RESOLVE_IMPORT(mono_class_get_nested_types );
RESOLVE_IMPORT(mono_class_get_userdata_offset );
RESOLVE_IMPORT(mono_class_get_userdata );
RESOLVE_IMPORT(mono_class_set_userdata );
RESOLVE_IMPORT(mono_set_signal_chaining );
RESOLVE_IMPORT(mono_unity_set_unhandled_exception_handler );
RESOLVE_IMPORT(mono_runtime_invoke_array );
RESOLVE_IMPORT(mono_array_addr_with_size );
RESOLVE_IMPORT(mono_string_to_utf16 );
RESOLVE_IMPORT(mono_field_get_parent );
RESOLVE_IMPORT(mono_method_full_name );
RESOLVE_IMPORT(mono_object_isinst );
RESOLVE_IMPORT(mono_string_new_len );
RESOLVE_IMPORT(mono_string_from_utf16 );
RESOLVE_IMPORT(mono_class_get );
RESOLVE_IMPORT(mono_string_new_utf16 );
}
uintptr_t monofunctions::get_method_pointer(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCount,bool strict) {
auto thread=AutoThread(); auto thread=AutoThread();
if(!thread.thread)return NULL; if(!thread.thread)return NULL;
@ -565,3 +229,17 @@ uintptr_t getmonofunctionptr(const char *_dll, const char *_namespace, const cha
} }
return NULL; return NULL;
} }
std::optional<std::wstring_view> monofunctions::get_string(void* ptr){
auto str=reinterpret_cast<MonoString*>(ptr);
if(!str)return {};
auto wc=(SafeFptr(mono_string_chars))(str);
auto len=(SafeFptr(mono_string_length))(str);
if(!(wc&&len))return {};
return std::wstring_view((wchar_t*)wc,len);
}
void* monofunctions::create_string(std::wstring_view ws){
auto domain=(SafeFptr(mono_domain_get))();
if(!domain)return nullptr;
return (SafeFptr(mono_string_new_utf16))(domain,(gunichar2*)ws.data(),ws.length());
}

11
LunaHook/engines/mono/monocommon.hpp
View File

@ -1,4 +1,5 @@
#include"def_mono.hpp"
#include"def_il2cpp.hpp"
#include"monostringapis.h" #include"monostringapis.h"
namespace { namespace {
@ -145,9 +146,9 @@ namespace monocommon{
bool hook_mono_il2cpp(){ bool hook_mono_il2cpp(){
for (const wchar_t* monoName : { L"mono.dll", L"mono-2.0-bdwgc.dll",L"GameAssembly.dll" }) for (const wchar_t* monoName : { L"mono.dll", L"mono-2.0-bdwgc.dll",L"GameAssembly.dll" })
if (HMODULE module = GetModuleHandleW(monoName)) { if (HMODULE module = GetModuleHandleW(monoName)) {
bool b2=monodllhook(module); //bool b2=monodllhook(module);
load_mono_functions_from_dll(module); il2cppfunctions::init(module);
il2cpp_symbols::init(module); monofunctions::init(module);
bool succ=false; bool succ=false;
for(auto hook:commonhooks){ for(auto hook:commonhooks){
auto addr=tryfindmonoil2cpp(hook.assemblyName,hook.namespaze,hook.klassName,hook.name,hook.argsCount); auto addr=tryfindmonoil2cpp(hook.assemblyName,hook.namespaze,hook.klassName,hook.name,hook.argsCount);
@ -159,7 +160,7 @@ namespace monocommon{
if(!addr)continue; if(!addr)continue;
succ|=NewHook_check(addr,hook); succ|=NewHook_check(addr,hook);
} }
if(succ||b2)return true; if(succ)return true;
} }
return false; return false;
} }

47
LunaHook/engines/mono/monoil2cpp.cpp Normal file
View File

@ -0,0 +1,47 @@
#include"def_mono.hpp"
#include"def_il2cpp.hpp"
namespace{
std::optional<std::wstring_view> readmonostring(void* ptr){
if(!ptr)return {};
MonoString* string = (MonoString*)ptr;
auto data = (wchar_t*)string->chars;
auto len=string->length;
if(!(len&&data))return {};
if(wcslen(data)!=len)return {};
return std::wstring_view(data,len);
}
void* createmonostring(std::wstring_view ws,MonoString* origin){
auto newstring=(MonoString*)malloc(sizeof(MonoString)+ws.size()+2);
memcpy(newstring,origin,sizeof(MonoString));
memcpy((wchar_t*)newstring->chars,ws.data(),ws.size()*2);
newstring->length=ws.size();
return newstring;
}
}
void commonsolvemonostring(uintptr_t offset,uintptr_t *data, size_t*len){
auto sw=il2cppfunctions::get_string((void*)offset);
if(!sw)sw=monofunctions::get_string((void*)offset);
if(!sw)sw=readmonostring((void*)offset);
if(!sw)return;
auto sw_v=sw.value();
*data=(uintptr_t)sw_v.data();
*len=sw_v.length()*sizeof(wchar_t);
//tostring|substring有时会会崩，非法指针或者长度爆炸
if(wcslen(sw_v.data())!=sw_v.size())
*len=0;
}
void unity_ui_string_hook_after(uintptr_t *offset,void* data, size_t len)
{
auto view=std::wstring_view((wchar_t*)data,len/2);
auto newstring=il2cppfunctions::create_string(view);
if(!newstring)newstring=monofunctions::create_string(view);
if(!newstring)newstring=createmonostring(view,(MonoString*)*offset);
*offset=(uintptr_t)newstring;
}
uintptr_t tryfindmonoil2cpp(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCoun,bool strict){
auto addr=il2cppfunctions::get_method_pointer(_dll,_namespace,_class,_method,paramCoun,strict);
if(addr)return addr;
return monofunctions::get_method_pointer(_dll,_namespace,_class,_method,paramCoun,strict);
}

9
LunaHook/engines/mono/monoil2cpp.h Normal file
View File

@ -0,0 +1,9 @@
#define RESOLVE_IMPORT(name) name = (decltype(name))(GetProcAddress(game_module, #name))
void commonsolvemonostring(uintptr_t offset,uintptr_t *data, size_t*len);
void unity_ui_string_hook_after(uintptr_t *offset,void* data, size_t len);
uintptr_t tryfindmonoil2cpp(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCoun,bool strict=false);

37
LunaHook/engines/mono/monoil2cpp.hpp
View File

@ -1,37 +0,0 @@
#include"def_mono.hpp"
#include"def_il2cpp.hpp"
inline void commonsolvemonostring(uintptr_t offset,uintptr_t *data, size_t*len){
MonoString* string = (MonoString*)offset;
if(string==0)return;
*data = (uintptr_t)string->chars;
if(wcslen((wchar_t*)string->chars)!=string->length)return;
*len = string->length * 2;
}
inline void unity_ui_string_hook_after(uintptr_t *offset,void* data, size_t len)
{
MonoString* string = (MonoString*)*offset;
if(string==0)return;
if(wcslen((wchar_t*)string->chars)!=string->length)return;
//其实也可以直接覆写到原来的String上，但重新创建一个是更安全的操作。
auto newstring=(MonoString*)malloc(sizeof(MonoString)+len+2);
memcpy(newstring,string,sizeof(MonoString));
wcscpy((wchar_t*)newstring->chars,(wchar_t*)data);
newstring->length=len/2;
*offset=(uintptr_t)newstring;
}
void load_mono_functions_from_dll(HMODULE dll);
uintptr_t getmonofunctionptr(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCount,bool strict);
inline uintptr_t tryfindmonoil2cpp(const char *_dll, const char *_namespace, const char *_class, const char *_method, int paramCoun,bool strict=false){
auto addr=il2cpp_symbols::get_method_pointer(_dll,_namespace,_class,_method,paramCoun,strict);
if(addr)return addr;
return getmonofunctionptr(_dll,_namespace,_class,_method,paramCoun,strict);
}

2
LunaHook/pchhook.h
View File

@ -25,7 +25,7 @@ enum { TEXT_BUFFER_SIZE = PIPE_BUFFER_SIZE - sizeof(TextOutput_T) };
#include"Lang/Lang.h" #include"Lang/Lang.h"
#include"veh_hook.h" #include"veh_hook.h"
#include"engines/emujitarg.hpp" #include"engines/emujitarg.hpp"
#include"engines/mono/monoil2cpp.hpp" #include"engines/mono/monoil2cpp.h"
#include "hookfinder.h" #include "hookfinder.h"
#include"util/textunion.h" #include"util/textunion.h"
#include"util/ntxpundef.h" #include"util/ntxpundef.h"