mirrors/mkxp-z
1
0
Fork 0
mirror of https://github.com/mkxp-z/mkxp-z.git synced 2025-08-04 05:55:31 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Satisfy hardened runtime dyld path reqs in Win32API

Browse source
This commit is contained in:
Struma 2021-04-15 23:59:27 -04:00 • committed by Roza
parent 7f35003e3f
commit f583683609
2 changed files with 239 additions and 232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

469
binding/miniffi-binding.cpp
View file

@ -5,20 +5,21 @@
#include <SDL.h> #include <SDL.h>
#include <cstdint> #include <cstdint>
#include "filesystem/filesystem.h"
#include "miniffi.h" #include "miniffi.h"
#include "binding-util.h" #include "binding-util.h"
#if defined(__linux__) || defined(__APPLE__) #if defined(__linux__) || defined(__APPLE__)
#define MVAL2RB(v) ULONG2NUM(v) #define MVAL2RB(v) ULONG2NUM(v)
#define RB2MVAL(v) (mffi_value)NUM2ULONG(v) #define RB2MVAL(v) (mffi_value)NUM2ULONG(v)
#else #else
#ifdef __MINGW64__ #ifdef __MINGW64__
#define MVAL2RB(v) ULL2NUM(v) #define MVAL2RB(v) ULL2NUM(v)
#define RB2MVAL(v) (mffi_value)NUM2ULL(v) #define RB2MVAL(v) (mffi_value)NUM2ULL(v)
#else #else
#define MVAL2RB(v) UINT2NUM(v) #define MVAL2RB(v) UINT2NUM(v)
#define RB2MVAL(v) (mffi_value)NUM2UINT(v) #define RB2MVAL(v) (mffi_value)NUM2UINT(v)
#endif #endif
#endif #endif
#define _T_VOID 0 #define _T_VOID 0
@ -36,253 +37,257 @@ DEF_ALLOCFUNC_CUSTOMFREE(MiniFFI, SDL_UnloadObject);
static void *MiniFFI_GetFunctionHandle(void *libhandle, const char *func) { static void *MiniFFI_GetFunctionHandle(void *libhandle, const char *func) {
#ifdef MKXPZ_ESSENTIALS_DEBUG #ifdef MKXPZ_ESSENTIALS_DEBUG
#define CAPTURE(n) \ #define CAPTURE(n) \
if (!strcmp(#n, func)) \ if (!strcmp(#n, func)) \
return (void *)&MKXP_##n return (void *)&MKXP_##n
CAPTURE(GetCurrentThreadId); CAPTURE(GetCurrentThreadId);
CAPTURE(GetWindowThreadProcessId); CAPTURE(GetWindowThreadProcessId);
CAPTURE(FindWindowEx); CAPTURE(FindWindowEx);
CAPTURE(GetForegroundWindow); CAPTURE(GetForegroundWindow);
CAPTURE(GetClientRect); CAPTURE(GetClientRect);
CAPTURE(GetCursorPos); CAPTURE(GetCursorPos);
CAPTURE(ScreenToClient); CAPTURE(ScreenToClient);
CAPTURE(SetWindowPos); CAPTURE(SetWindowPos);
CAPTURE(SetWindowTextA); CAPTURE(SetWindowTextA);
CAPTURE(GetWindowRect); CAPTURE(GetWindowRect);
CAPTURE(GetKeyboardState); CAPTURE(GetKeyboardState);
#ifndef __WIN32__ #ifndef __WIN32__
// Functions only needed on Linux and macOS go here // Functions only needed on Linux and macOS go here
CAPTURE(RtlMoveMemory); CAPTURE(RtlMoveMemory);
CAPTURE(LoadLibrary); CAPTURE(LoadLibrary);
CAPTURE(FreeLibrary); CAPTURE(FreeLibrary);
CAPTURE(GetAsyncKeyState); CAPTURE(GetAsyncKeyState);
CAPTURE(GetSystemPowerStatus); CAPTURE(GetSystemPowerStatus);
CAPTURE(ShowWindow); CAPTURE(ShowWindow);
CAPTURE(GetSystemMetrics); CAPTURE(GetSystemMetrics);
CAPTURE(SetCapture); CAPTURE(SetCapture);
CAPTURE(ReleaseCapture); CAPTURE(ReleaseCapture);
CAPTURE(ShowCursor); CAPTURE(ShowCursor);
CAPTURE(GetPrivateProfileString); CAPTURE(GetPrivateProfileString);
CAPTURE(GetUserDefaultLangID); CAPTURE(GetUserDefaultLangID);
CAPTURE(GetUserName); CAPTURE(GetUserName);
CAPTURE(RegisterHotKey); CAPTURE(RegisterHotKey);
CAPTURE(SetWindowLong); CAPTURE(SetWindowLong);
#endif #endif
#endif #endif
if (!libhandle) if (!libhandle)
return 0; return 0;
return SDL_LoadFunction(libhandle, func); return SDL_LoadFunction(libhandle, func);
} }
// MiniFFI.new(library, function[, imports[, exports]]) // MiniFFI.new(library, function[, imports[, exports]])
// Yields itself in blocks // Yields itself in blocks
RB_METHOD(MiniFFI_initialize) { RB_METHOD(MiniFFI_initialize) {
VALUE libname, func, imports, exports; VALUE libname, func, imports, exports;
rb_scan_args(argc, argv, "22", &libname, &func, &imports, &exports); rb_scan_args(argc, argv, "22", &libname, &func, &imports, &exports);
SafeStringValue(libname); SafeStringValue(libname);
SafeStringValue(func); SafeStringValue(func);
void *hlib = SDL_LoadObject(RSTRING_PTR(libname)); #ifdef __MACOSX__
setPrivateData(self, hlib); void *hlib = SDL_LoadObject(mkxp_fs::normalizePath(RSTRING_PTR(libname), 1, 1).c_str());
void *hfunc = MiniFFI_GetFunctionHandle(hlib, RSTRING_PTR(func)); #else
#ifdef __WIN32__ void *hlib = SDL_LoadObject(RSTRING_PTR(libname));
if (hlib && !hfunc) {
VALUE func_a = rb_str_new3(func);
func_a = rb_str_cat(func_a, "A", 1);
hfunc = SDL_LoadFunction(hlib, RSTRING_PTR(func_a));
}
#endif #endif
if (!hfunc) setPrivateData(self, hlib);
rb_raise(rb_eRuntimeError, "%s", SDL_GetError()); void *hfunc = MiniFFI_GetFunctionHandle(hlib, RSTRING_PTR(func));
#ifdef __WIN32__
rb_iv_set(self, "_func", MVAL2RB((mffi_value)hfunc)); if (hlib && !hfunc) {
rb_iv_set(self, "_funcname", func); VALUE func_a = rb_str_new3(func);
rb_iv_set(self, "_libname", libname); func_a = rb_str_cat(func_a, "A", 1);
hfunc = SDL_LoadFunction(hlib, RSTRING_PTR(func_a));
VALUE ary_imports = rb_ary_new();
VALUE *entry;
switch (TYPE(imports)) {
case T_NIL:
break;
case T_ARRAY:
entry = RARRAY_PTR(imports);
for (int i = 0; i < RARRAY_LEN(imports); i++) {
SafeStringValue(entry[i]);
switch (*(char *)RSTRING_PTR(entry[i])) {
case 'N':
case 'n':
case 'L':
case 'l':
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER));
break;
case 'P':
case 'p':
rb_ary_push(ary_imports, INT2FIX(_T_POINTER));
break;
case 'I':
case 'i':
rb_ary_push(ary_imports, INT2FIX(_T_INTEGER));
break;
case 'B':
case 'b':
rb_ary_push(ary_imports, INT2FIX(_T_BOOL));
break;
}
} }
break; #endif
default: if (!hfunc)
SafeStringValue(imports); rb_raise(rb_eRuntimeError, "%s", SDL_GetError());
const char *s = RSTRING_PTR(imports);
for (int i = 0; i < RSTRING_LEN(imports); i++) { rb_iv_set(self, "_func", MVAL2RB((mffi_value)hfunc));
switch (*s++) { rb_iv_set(self, "_funcname", func);
case 'N': rb_iv_set(self, "_libname", libname);
case 'n':
case 'L': VALUE ary_imports = rb_ary_new();
case 'l': VALUE *entry;
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER)); switch (TYPE(imports)) {
break; case T_NIL:
break;
case 'P': case T_ARRAY:
case 'p': entry = RARRAY_PTR(imports);
rb_ary_push(ary_imports, INT2FIX(_T_POINTER)); for (int i = 0; i < RARRAY_LEN(imports); i++) {
break; SafeStringValue(entry[i]);
switch (*(char *)RSTRING_PTR(entry[i])) {
case 'I': case 'N':
case 'i': case 'n':
rb_ary_push(ary_imports, INT2FIX(_T_INTEGER)); case 'L':
break; case 'l':
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER));
case 'B': break;
case 'b':
rb_ary_push(ary_imports, INT2FIX(_T_BOOL)); case 'P':
break; case 'p':
} rb_ary_push(ary_imports, INT2FIX(_T_POINTER));
break;
case 'I':
case 'i':
rb_ary_push(ary_imports, INT2FIX(_T_INTEGER));
break;
case 'B':
case 'b':
rb_ary_push(ary_imports, INT2FIX(_T_BOOL));
break;
}
}
break;
default:
SafeStringValue(imports);
const char *s = RSTRING_PTR(imports);
for (int i = 0; i < RSTRING_LEN(imports); i++) {
switch (*s++) {
case 'N':
case 'n':
case 'L':
case 'l':
rb_ary_push(ary_imports, INT2FIX(_T_NUMBER));
break;
case 'P':
case 'p':
rb_ary_push(ary_imports, INT2FIX(_T_POINTER));
break;
case 'I':
case 'i':
rb_ary_push(ary_imports, INT2FIX(_T_INTEGER));
break;
case 'B':
case 'b':
rb_ary_push(ary_imports, INT2FIX(_T_BOOL));
break;
}
}
break;
} }
break;
} if (MINIFFI_MAX_ARGS < RARRAY_LEN(ary_imports))
rb_raise(rb_eRuntimeError, "too many parameters: %ld/%ld\n",
if (MINIFFI_MAX_ARGS < RARRAY_LEN(ary_imports)) RARRAY_LEN(ary_imports), MINIFFI_MAX_ARGS);
rb_raise(rb_eRuntimeError, "too many parameters: %ld/%ld\n",
RARRAY_LEN(ary_imports), MINIFFI_MAX_ARGS); rb_iv_set(self, "_imports", ary_imports);
int ex;
rb_iv_set(self, "_imports", ary_imports); if (NIL_P(exports)) {
int ex; ex = _T_VOID;
if (NIL_P(exports)) { } else {
ex = _T_VOID; SafeStringValue(exports);
} else { switch (*RSTRING_PTR(exports)) {
SafeStringValue(exports); case 'V':
switch (*RSTRING_PTR(exports)) { case 'v':
case 'V': ex = _T_VOID;
case 'v': break;
ex = _T_VOID;
break; case 'N':
case 'n':
case 'N': case 'L':
case 'n': case 'l':
case 'L': ex = _T_NUMBER;
case 'l': break;
ex = _T_NUMBER;
break; case 'P':
case 'p':
case 'P': ex = _T_POINTER;
case 'p': break;
ex = _T_POINTER;
break; case 'I':
case 'i':
case 'I': ex = _T_INTEGER;
case 'i': break;
ex = _T_INTEGER;
break; case 'B':
case 'b':
case 'B': ex = _T_BOOL;
case 'b': break;
ex = _T_BOOL; }
break;
} }
} rb_iv_set(self, "_exports", INT2FIX(ex));
rb_iv_set(self, "_exports", INT2FIX(ex)); if (rb_block_given_p())
if (rb_block_given_p()) rb_yield(self);
rb_yield(self); return Qnil;
return Qnil;
} }
RB_METHOD(MiniFFI_call) { RB_METHOD(MiniFFI_call) {
MiniFFIFuncArgs param; MiniFFIFuncArgs param;
#define params param.params #define params param.params
VALUE func = rb_iv_get(self, "_func"); VALUE func = rb_iv_get(self, "_func");
VALUE own_imports = rb_iv_get(self, "_imports"); VALUE own_imports = rb_iv_get(self, "_imports");
VALUE own_exports = rb_iv_get(self, "_exports"); VALUE own_exports = rb_iv_get(self, "_exports");
MINIFFI_FUNC ApiFunction = (MINIFFI_FUNC)RB2MVAL(func); MINIFFI_FUNC ApiFunction = (MINIFFI_FUNC)RB2MVAL(func);
VALUE args; VALUE args;
int items = rb_scan_args(argc, argv, "0*", &args); int items = rb_scan_args(argc, argv, "0*", &args);
int nimport = RARRAY_LEN(own_imports); int nimport = RARRAY_LEN(own_imports);
if (items != nimport) if (items != nimport)
rb_raise(rb_eRuntimeError, rb_raise(rb_eRuntimeError,
"wrong number of parameters: expected %d, got %d", nimport, items); "wrong number of parameters: expected %d, got %d", nimport, items);
for (int i = 0; i < nimport; i++) { for (int i = 0; i < nimport; i++) {
VALUE str = rb_ary_entry(args, i); VALUE str = rb_ary_entry(args, i);
mffi_value lParam = 0; mffi_value lParam = 0;
switch (FIX2INT(rb_ary_entry(own_imports, i))) { switch (FIX2INT(rb_ary_entry(own_imports, i))) {
case _T_POINTER: case _T_POINTER:
if (NIL_P(str)) { if (NIL_P(str)) {
lParam = 0; lParam = 0;
} else if (FIXNUM_P(str)) { } else if (FIXNUM_P(str)) {
lParam = RB2MVAL(str); lParam = RB2MVAL(str);
} else { } else {
StringValue(str); StringValue(str);
rb_str_modify(str); rb_str_modify(str);
lParam = (mffi_value)RSTRING_PTR(str); lParam = (mffi_value)RSTRING_PTR(str);
} }
break; break;
case _T_BOOL: case _T_BOOL:
lParam = RTEST(rb_ary_entry(args, i)); lParam = RTEST(rb_ary_entry(args, i));
break; break;
case _T_INTEGER: case _T_INTEGER:
#if INTPTR_MAX == INT64_MAX #if INTPTR_MAX == INT64_MAX
lParam = RB2MVAL(rb_ary_entry(args, i)) & UINT32_MAX; lParam = RB2MVAL(rb_ary_entry(args, i)) & UINT32_MAX;
break; break;
#endif #endif
case _T_NUMBER: case _T_NUMBER:
default: default:
lParam = RB2MVAL(rb_ary_entry(args, i)); lParam = RB2MVAL(rb_ary_entry(args, i));
break; break;
}
params[i] = lParam;
}
mffi_value ret = miniffi_call_intern(ApiFunction, &param, nimport);
switch (FIX2INT(own_exports)) {
case _T_NUMBER:
case _T_INTEGER:
return MVAL2RB(ret);
case _T_POINTER:
return rb_utf8_str_new_cstr((char *)ret);
case _T_BOOL:
return rb_bool_new(ret);
case _T_VOID:
default:
return MVAL2RB(0);
} }
params[i] = lParam;
}
mffi_value ret = miniffi_call_intern(ApiFunction, &param, nimport);
switch (FIX2INT(own_exports)) {
case _T_NUMBER:
case _T_INTEGER:
return MVAL2RB(ret);
case _T_POINTER:
return rb_utf8_str_new_cstr((char *)ret);
case _T_BOOL:
return rb_bool_new(ret);
case _T_VOID:
default:
return MVAL2RB(0);
}
} }
void MiniFFIBindingInit() { void MiniFFIBindingInit() {
VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject); VALUE cMiniFFI = rb_define_class("MiniFFI", rb_cObject);
#if RAPI_FULL > 187 #if RAPI_FULL > 187
rb_define_alloc_func(cMiniFFI, classAllocate<&MiniFFIType>); rb_define_alloc_func(cMiniFFI, classAllocate<&MiniFFIType>);
#else #else
rb_define_alloc_func(cMiniFFI, MiniFFIAllocate); rb_define_alloc_func(cMiniFFI, MiniFFIAllocate);
#endif #endif
_rb_define_method(cMiniFFI, "initialize", MiniFFI_initialize); _rb_define_method(cMiniFFI, "initialize", MiniFFI_initialize);
_rb_define_method(cMiniFFI, "call", MiniFFI_call); _rb_define_method(cMiniFFI, "call", MiniFFI_call);
rb_define_alias(cMiniFFI, "Call", "call"); rb_define_alias(cMiniFFI, "Call", "call");
rb_define_const(rb_cObject, "Win32API", cMiniFFI); rb_define_const(rb_cObject, "Win32API", cMiniFFI);
} }

2
macos/mkxp.entitlements
View file

@ -2,6 +2,8 @@
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0"> <plist version="1.0">
<dict> <dict>
<key>com.apple.security.cs.allow-dyld-environment-variables</key>
<true/>
<key>com.apple.security.cs.allow-unsigned-executable-memory</key> <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
<true/> <true/>
<key>com.apple.security.cs.disable-library-validation</key> <key>com.apple.security.cs.disable-library-validation</key>