diff --git a/microscript/ILibDuktape_GenericMarshal.c b/microscript/ILibDuktape_GenericMarshal.c index 7522d76..2973133 100644 --- a/microscript/ILibDuktape_GenericMarshal.c +++ b/microscript/ILibDuktape_GenericMarshal.c @@ -55,10 +55,12 @@ typedef uintptr_t PTRSIZE; #define ILibDuktape_GenericMarshal_StashTable "\xFF_GenericMarshal_StashTable" #define ILibDuktape_GenericMarshal_GlobalCallback_ThreadID "\xFF_GenericMarshal_ThreadID" #define ILibDutkape_GenericMarshal_INTERNAL "\xFF_INTERNAL" +#define ILibDutkape_GenericMarshal_INTERNAL_X "\xFF_INTERNAL_X" #define ILibDuktape_GenericMarshal_Variable_EnableAutoFree(ctx, idx) duk_dup(ctx, idx);duk_push_true(ctx);duk_put_prop_string(ctx, -2, ILibDuktape_GenericMarshal_Variable_AutoFree);duk_pop(ctx) #define ILibDuktape_GenericMarshal_Variable_DisableAutoFree(ctx, idx) duk_dup(ctx, idx);duk_push_false(ctx);duk_put_prop_string(ctx, -2, ILibDuktape_GenericMarshal_Variable_AutoFree);duk_pop(ctx) #define WAITING_FOR_RESULT__DISPATCHER 2 #define ILibDuktape_GenericMarshal_MethodInvoke_Native(parms, fptr, vars) ILibDuktape_GenericMarshal_MethodInvoke_NativeEx(parms, fptr, vars, ILibDuktape_GenericMarshal_CallTypes_DEFAULT) +void ILibDuktape_GenericMarshal_Variable_PUSH(duk_context *ctx, void *ptr, int size); typedef PTRSIZE(APICALLTYPE *R0)(); typedef PTRSIZE(APICALLTYPE *R1)(PTRSIZE V1); @@ -142,6 +144,176 @@ uintptr_t ILibDuktape_GenericMarshal_MethodInvoke_CustomEx(int parms, void *fptr } +ILibDuktape_EventEmitter *GenericMarshal_CustomEventHandler_Events[255] = { 0 }; +void ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler_Setup(duk_context *ctx, void *func, uint32_t index) +{ + if (index < 0 || index >((sizeof(GenericMarshal_CustomEventHandler_Events) / sizeof(uintptr_t)) - 1)) + { + ILibDuktape_Error(ctx, "Custom Event Index out of range"); + return; + } + + ILibDuktape_GenericMarshal_Variable_PUSH(ctx, func, sizeof(uintptr_t)); + ILibDuktape_GenericMarshal_Variable_DisableAutoFree(ctx, -1); + ILibDuktape_EventEmitter_CreateEventEx(ILibDuktape_EventEmitter_Create(ctx), "GlobalCallback"); + GenericMarshal_CustomEventHandler_Events[index] = ILibDuktape_EventEmitter_GetEmitter(ctx, -1); + duk_push_uint(ctx, index); + duk_put_prop_string(ctx, -2, ILibDutkape_GenericMarshal_INTERNAL_X); +} + +uintptr_t GenericMarshal_CustomEventHandler_DispatchEx(ILibDuktape_EventEmitter *e, uintptr_t *args, size_t argsLen) +{ + duk_context *ctx = e->ctx; + uintptr_t ret = 0; + size_t i; + ILibDuktape_EventEmitter_SetupEmit(e->ctx, e->object, "GlobalCallback"); // [emit][this][Name] + for (i = 0; i < argsLen; ++i) + { + ILibDuktape_GenericMarshal_Variable_PUSH(e->ctx, (void*)args[i], sizeof(uintptr_t)); // [emit][this][Name][...] + ILibDuktape_GenericMarshal_Variable_DisableAutoFree(e->ctx, -1); + } + if (duk_pcall_method(e->ctx, (duk_idx_t)argsLen + 1) == 0) + { + if (ILibMemory_CanaryOK(e)) + { + if (e->lastReturnValue != NULL) + { + duk_push_heapptr(e->ctx, e->lastReturnValue); + ret = (uintptr_t)Duktape_GetPointerProperty(ctx, -1, "_ptr"); + duk_pop(ctx); + } + } + } + duk_pop(ctx); + return(ret); +} + +typedef struct GenericMarshal_CustomEventHandler_Dispatch_Data +{ + ILibDuktape_EventEmitter *emitter; + uintptr_t *args; + size_t argsLen; + uintptr_t ret; + sem_t waiter; +}GenericMarshal_CustomEventHandler_Dispatch_Data; + +void GenericMarshal_CustomEventHandler_Dispatch_Chain(void *chain, void *user) +{ + GenericMarshal_CustomEventHandler_Dispatch_Data *data = (GenericMarshal_CustomEventHandler_Dispatch_Data*)user; + duk_push_heapptr(data->emitter->ctx, data->emitter->object); // [obj] + duk_push_true(data->emitter->ctx); // [obj][true] + duk_put_prop_string(data->emitter->ctx, -2, "callbackDispatched"); // [obj] + data->ret = GenericMarshal_CustomEventHandler_DispatchEx(data->emitter, data->args, data->argsLen); + duk_del_prop_string(data->emitter->ctx, -1, "callbackDispatched"); + sem_post(&(data->waiter)); +} +uintptr_t GenericMarshal_CustomEventHandler_Dispatch(uintptr_t *args, size_t argsLen, uint32_t index) +{ + uintptr_t ret = 0; + ILibDuktape_EventEmitter *emitter = GenericMarshal_CustomEventHandler_Events[index]; + if (emitter != NULL && ILibMemory_CanaryOK(emitter)) + { + int dispatch = ILibIsRunningOnChainThread(duk_ctx_chain(emitter->ctx)) == 0; + GenericMarshal_CustomEventHandler_Dispatch_Data user = { 0 }; + + if (dispatch) + { + user.args = args; + user.argsLen = argsLen; + user.emitter = emitter; + sem_init(&(user.waiter), 0, 0); + ILibChain_RunOnMicrostackThread(duk_ctx_chain(emitter->ctx), GenericMarshal_CustomEventHandler_Dispatch_Chain, &user); + sem_wait(&(user.waiter)); + sem_destroy(&(user.waiter)); + ret = user.ret; + } + else + { + ret = GenericMarshal_CustomEventHandler_DispatchEx(emitter, args, argsLen); + } + } + return(ret); +} + +#ifdef WIN32 +uintptr_t __stdcall GenericMarshal_CustomEventHandler_10(uintptr_t var1, uintptr_t var2, uintptr_t var3) +{ + uintptr_t args[] = { var1, var2, var3 }; + return(GenericMarshal_CustomEventHandler_Dispatch(args, sizeof(args) / sizeof(uintptr_t), 10)); +} +uintptr_t __stdcall GenericMarshal_CustomEventHandler_11(uintptr_t var1) +{ + uintptr_t args[] = { var1 }; + return(GenericMarshal_CustomEventHandler_Dispatch(args, sizeof(args) / sizeof(uintptr_t), 11)); +} +uintptr_t __stdcall GenericMarshal_CustomEventHandler_12(uintptr_t var1) +{ + uintptr_t args[] = { var1 }; + return(GenericMarshal_CustomEventHandler_Dispatch(args, sizeof(args) / sizeof(uintptr_t), 12)); +} +uintptr_t __stdcall GenericMarshal_CustomEventHandler_13(uintptr_t var1, uintptr_t var2, uintptr_t var3) +{ + uintptr_t args[] = { var1, var2, var3 }; + return(GenericMarshal_CustomEventHandler_Dispatch(args, sizeof(args) / sizeof(uintptr_t), 13)); +} +uintptr_t __stdcall GenericMarshal_CustomEventHandler_14(uintptr_t var1, uintptr_t var2, uintptr_t var3, uintptr_t var4, uintptr_t var5) +{ + uintptr_t args[] = { var1, var2, var3, var4, var5 }; + return(GenericMarshal_CustomEventHandler_Dispatch(args, sizeof(args) / sizeof(uintptr_t), 14)); +} +#endif + +void ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler(duk_context *ctx, int paramCount, uint32_t index) +{ + int ok = 0; + switch (index) + { +#ifdef WIN32 + case 10: + if (paramCount == 3) + { + ok = 1; + ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler_Setup(ctx, GenericMarshal_CustomEventHandler_10, index); + } + break; + case 11: + if (paramCount == 1) + { + ok = 1; + ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler_Setup(ctx, GenericMarshal_CustomEventHandler_11, index); + } + break; + case 12: + if (paramCount == 1) + { + ok = 1; + ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler_Setup(ctx, GenericMarshal_CustomEventHandler_12, index); + } + break; + case 13: + if (paramCount == 3) + { + ok = 1; + ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler_Setup(ctx, GenericMarshal_CustomEventHandler_13, index); + } + break; + case 14: + if (paramCount == 5) + { + ok = 1; + ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler_Setup(ctx, GenericMarshal_CustomEventHandler_14, index); + } + break; +#endif + default: + ILibDuktape_Error(ctx, "Undefined Custom Event Handler Index: %u", index); + break; + } + if (ok == 0) + { + ILibDuktape_Error(ctx, "Invalid Parameter count: %d for Custom Event Handler Index: %u", paramCount, index); + } +} ILibLinkedList GlobalCallbackList = NULL; @@ -184,7 +356,6 @@ typedef struct Duktape_MarshalledObject void *heapptr; }Duktape_MarshalledObject; -void ILibDuktape_GenericMarshal_Variable_PUSH(duk_context *ctx, void *ptr, int size); duk_ret_t ILibDuktape_GenericMarshal_Variable_Val_STRING(duk_context *ctx) { @@ -501,11 +672,13 @@ duk_ret_t ILibDuktape_GenericMarshal_Variable_bignum_SET(duk_context *ctx) duk_ret_t ILibDuktape_GenericMarshal_Variable_Increment(duk_context *ctx) { duk_push_this(ctx); // [var] + int isAutoFree = Duktape_GetBooleanProperty(ctx, -1, ILibDuktape_GenericMarshal_Variable_AutoFree, 0); ILibDuktape_GenericMarshal_Variable_DisableAutoFree(ctx, -1); void *_ptr = Duktape_GetPointerProperty(ctx, -1, "_ptr"); int offset = duk_require_int(ctx, 0); if (duk_is_boolean(ctx, 1) && duk_require_boolean(ctx, 1)) { + if (isAutoFree != 0) { free(_ptr); } _ptr = (void*)(uintptr_t)duk_require_uint(ctx, 0); } else @@ -856,7 +1029,7 @@ PTRSIZE ILibDuktape_GenericMarshal_MethodInvoke_NativeEx(int parms, void *fptr, switch (calltype) { - case ILibDuktape_GenericMarshal_CallTypes_DEFAULT: + default: switch (parms) { case 0: @@ -2189,7 +2362,7 @@ void ILibDuktape_GlobalGenericCallbackEx_Process_ChainEx(void * chain, void *use if (ILibDuktape_GlobalGenericCallbackEx_Process_ChainEx_2(data->emitter) != 0) { // Exception was thrown - ILibDuktape_Process_UncaughtExceptionEx(data->emitter->ctx, "Exception occured in GlobalCallback: %s", duk_safe_to_string(data->emitter->ctx, -1)); + ILibDuktape_Process_UncaughtExceptionEx(ctx, "Exception occured in GlobalCallback: %s", duk_safe_to_string(ctx, -1)); data->retVal = NULL; } else @@ -2473,7 +2646,15 @@ duk_ret_t ILibDuktape_GenericMarshal_PutGlobalGenericCallbackEx(duk_context *ctx duk_get_prop_string(ctx, -1, "GlobalCallBacksEx"); // [stash][array] if (!duk_has_prop_string(ctx, 0, ILibDutkape_GenericMarshal_INTERNAL)) { - return(ILibDuktape_Error(ctx, "Invalid Parameter")); + if (duk_has_prop_string(ctx, 0, ILibDutkape_GenericMarshal_INTERNAL_X)) + { + uint32_t x = Duktape_GetUIntPropertyValue(ctx, 0, ILibDutkape_GenericMarshal_INTERNAL_X, 0); + if (x < sizeof(GenericMarshal_CustomEventHandler_Events) / sizeof(void*)) + { + GenericMarshal_CustomEventHandler_Events[x] = NULL; + } + } + return(0); } duk_get_prop_string(ctx, 0, ILibDutkape_GenericMarshal_INTERNAL); // [stash][array][obj] int index = Duktape_GetIntPropertyValue(ctx, -1, "INDEX", -1); @@ -2489,6 +2670,11 @@ duk_ret_t ILibDuktape_GenericMarshal_PutGlobalGenericCallbackEx(duk_context *ctx duk_ret_t ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx(duk_context *ctx) { int numParms = duk_require_int(ctx, 0); + if (duk_is_number(ctx, 1)) + { + ILibDuktape_GenericMarshal_GetGlobalGenericCallbackEx_CustomHandler(ctx, numParms, duk_require_uint(ctx, 1)); + return(1); + } duk_push_global_stash(ctx); // [stash] if (!duk_has_prop_string(ctx, -1, "GlobalCallBacksEx")) diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index 0bf0822..d4e19af 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2394,10 +2394,10 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) duk_peval_string_noresult(ctx, "addCompressedModule('win-systray', Buffer.from('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', 'base64'));"); // win-com is a helper to add COM support. Refer to modules/win-com.js - duk_peval_string_noresult(ctx, "addCompressedModule('win-com', Buffer.from('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', 'base64'), '2022-03-28T11:47:40.000-07:00');"); + duk_peval_string_noresult(ctx, "addCompressedModule('win-com', Buffer.from('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', 'base64'), '2022-04-13T12:34:25.000-07:00');"); // win-wmi is a helper to add wmi support using win-com. Refer to modules/win-wmi.js - duk_peval_string_noresult(ctx, "addCompressedModule('win-wmi', Buffer.from('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', 'base64'), '2021-11-09T11:50:29.000-08:00');"); + duk_peval_string_noresult(ctx, "addCompressedModule('win-wmi', Buffer.from('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', 'base64'), '2022-04-13T23:23:25.000-07:00');"); // Simple COM BASED Task Scheduler for Windows. Refer to modules/win-tasks.js duk_peval_string_noresult(ctx, "addCompressedModule('win-tasks', Buffer.from('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', 'base64'), '2022-03-28T11:39:32.000-07:00');"); diff --git a/modules/win-com.js b/modules/win-com.js index 0de87e5..953cd79 100644 --- a/modules/win-com.js +++ b/modules/win-com.js @@ -98,7 +98,17 @@ function marshalFunctions(obj, arr) } function marshalInterface(arr) { - if (GM.PointerSize == 4) { throw ('Not supported on 32bit platforms, becuase ellipses function cannot be __stdcall'); } + if (GM.PointerSize == 4) + { + // For 32 bit, we need to check to make sure custom handlers were used + for (var i = 0; i < arr.length; ++i) + { + if (arr[i].cx == null) + { + throw ('Not supported on 32bit platforms, becuase ellipses function cannot be __stdcall'); + } + } + } var vtbl = GM.CreateVariable(arr.length * GM.PointerSize); var obj = GM.CreatePointer(); vtbl.pointerBuffer().copy(obj.toBuffer()); @@ -117,7 +127,7 @@ function marshalInterface(arr) for (var i = 0; i < arr.length; ++i) { - _hide(GM.GetGenericGlobalCallbackEx(arr[i].parms)); + _hide(GM.GetGenericGlobalCallbackEx(arr[i].parms, GM.PointerSize == 4 ? arr[i].cx : null)); // Only 32 bit needs custom handlers _hide()._ObjectID = 'GlobalCallback_' + arr[i].name; obj._gcallbacks.push(_hide()); _hide().obj = arr[i]; diff --git a/modules/win-wmi.js b/modules/win-wmi.js index 49d1aff..eb536d1 100644 --- a/modules/win-wmi.js +++ b/modules/win-wmi.js @@ -99,7 +99,7 @@ const ResultFunctions = [ const QueryAsyncHandler = [ { - parms: 3, name: 'QueryInterface', func: function (j, riid, ppv) + cx: 10, parms: 3, name: 'QueryInterface', func: function (j, riid, ppv) { var ret = GM.CreateVariable(4); console.info1('QueryInterface', riid.Deref(0, 16).toBuffer().toString('hex')); @@ -127,7 +127,7 @@ const QueryAsyncHandler = } }, { - parms: 1, name: 'AddRef', func: function () + cx: 11, parms: 1, name: 'AddRef', func: function () { ++this.refcount; console.info1('AddRef', this.refcount); @@ -135,7 +135,7 @@ const QueryAsyncHandler = } }, { - parms: 1, name: 'Release', func: function () + cx: 12, parms: 1, name: 'Release', func: function () { --this.refcount; console.info1('Release', this.refcount); @@ -163,7 +163,7 @@ const QueryAsyncHandler = } }, { - parms: 3, name: 'Indicate', func: function (j, count, arr) + cx: 13, parms: 3, name: 'Indicate', func: function (j, count, arr) { console.info1('Indicate', count.Val); var j, nme, len, nn; @@ -180,7 +180,7 @@ const QueryAsyncHandler = } }, { - parms: 5, name: 'SetStatus', func: function (j, lFlags, hResult, strParam, pObjParam) + cx: 14, parms: 5, name: 'SetStatus', func: function (j, lFlags, hResult, strParam, pObjParam) { console.info1('SetStatus', hResult.Val);