diff --git a/meshcore/agentcore.c b/meshcore/agentcore.c index f09fe517d..f8e113b47 100644 --- a/meshcore/agentcore.c +++ b/meshcore/agentcore.c @@ -22,6 +22,7 @@ limitations under the License. #include "wincrypto.h" #include #include +#include "meshservice/resource.h" #endif #include "agentcore.h" @@ -3856,7 +3857,34 @@ void MeshServer_ConnectEx(MeshAgentHostContainer *agent) if (ILibIsChainBeingDestroyed(agent->chain) != 0) { return; } len = ILibSimpleDataStore_Get(agent->masterDb, "MeshServer", ILibScratchPad2, sizeof(ILibScratchPad2)); - if (len == 0) { printf("No MeshCentral settings found, place .msh file with this executable and restart.\r\n"); ILibRemoteLogging_printf(ILibChainGetLogger(agent->chain), ILibRemoteLogging_Modules_Microstack_Generic, ILibRemoteLogging_Flags_VerbosityLevel_1, "agentcore: MeshServer URI not found"); return; } + if (len == 0) { + printf("No MeshCentral settings found, place .msh file with this executable and restart.\r\n"); + ILibRemoteLogging_printf(ILibChainGetLogger(agent->chain), ILibRemoteLogging_Modules_Microstack_Generic, ILibRemoteLogging_Flags_VerbosityLevel_1, "agentcore: MeshServer URI not found"); + return; + } + +#ifdef WIN32 + // Check if winpty.dll and winpty-agent.exe are present and try to deploy them if not. + int length = ILibString_LastIndexOf(agent->exePath, strnlen_s(agent->exePath, MAX_PATH), "\\", 1) + 1; + char basePath[MAX_PATH]; + char winPtyDllPath[MAX_PATH]; + char winPtyAgentExePath[MAX_PATH]; + _snprintf_s(basePath, MAX_PATH, length, "%s", agent->exePath); + sprintf_s(winPtyDllPath, MAX_PATH, "%swinpty.dll", basePath); + sprintf_s(winPtyAgentExePath, MAX_PATH, "%swinpty-agent.exe", basePath); + if (GetFileAttributes(winPtyDllPath) == INVALID_FILE_ATTRIBUTES || + GetFileAttributes(winPtyAgentExePath) == INVALID_FILE_ATTRIBUTES && + GetLastError() == ERROR_FILE_NOT_FOUND) + { + printf("Either winpty.dll or winpty-agent.exe is missing. Trying to deploy missing dependencies.\r\n"); + duk_push_sprintf(agent->meshCoreCtx, "require('service-manager').manager.deployWinPtyDependencies('%s')", basePath); + duk_string_split(agent->meshCoreCtx, -1, "\\"); // [string][array] + duk_array_join(agent->meshCoreCtx, -1, "\\\\"); // [string][array][string] + duk_remove(agent->meshCoreCtx, -2); // [string][string] + duk_remove(agent->meshCoreCtx, -2); // [string] + duk_peval_noresult(agent->meshCoreCtx); + } +#endif if (ILibSimpleDataStore_Get(agent->masterDb, "autoproxy", ILibScratchPad, sizeof(ILibScratchPad)) != 0) { @@ -6341,8 +6369,6 @@ void MeshAgent_Stop(MeshAgentHostContainer *agent) ILibStopChain(agent->chain); } - - #ifdef WIN32 // Perform self-update (Windows console/tray version) void MeshAgent_PerformSelfUpdate(char* selfpath, char* exepath, int argc, char **argv) diff --git a/meshservice/MeshService.rc b/meshservice/MeshService.rc index dddc69bd0..7a6070ec5 100644 Binary files a/meshservice/MeshService.rc and b/meshservice/MeshService.rc differ diff --git a/meshservice/MeshService.vcxproj b/meshservice/MeshService.vcxproj index 3897d9354..f88a89dc2 100644 --- a/meshservice/MeshService.vcxproj +++ b/meshservice/MeshService.vcxproj @@ -195,7 +195,7 @@ Disabled ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;_WINSERVICE;_DEBUG;_CONSOLE;MEMORY_CHECK;__STDC__;WINSOCK2;ILibWebServer_SESSION_TRACKING;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_TLS_DETECT;_REMOTELOGGING;_REMOTELOGGINGSERVER;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;_WINSERVICE;_DEBUG;_CONSOLE;MEMORY_CHECK;__STDC__;WINSOCK2;ILibWebServer_SESSION_TRACKING;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_TLS_DETECT;_REMOTELOGGING;_REMOTELOGGINGSERVER;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) true EnableFastChecks MultiThreadedDebug @@ -235,12 +235,15 @@ $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + Disabled ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;_WINSERVICE;_DEBUG;_CONSOLE;MEMORY_CHECK;__STDC__;WINSOCK2;ILibWebServer_SESSION_TRACKING;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_NOTLS;_REMOTELOGGING;_REMOTELOGGINGSERVER;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;_WINSERVICE;_DEBUG;_CONSOLE;MEMORY_CHECK;__STDC__;WINSOCK2;ILibWebServer_SESSION_TRACKING;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_NOTLS;_REMOTELOGGING;_REMOTELOGGINGSERVER;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) true EnableFastChecks MultiThreadedDebug @@ -280,6 +283,9 @@ $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + @@ -288,7 +294,7 @@ Disabled ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;MICROSTACK_PROXY;_WINSERVICE;NOLMSCOMMANDER;WIN32;WIN64;_LINKVM;_DEBUG;_CONSOLE;MEMORY_CHECK;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;__STDC__;_CRT_SECURE_NO_WARNINGS;WINSOCK2;ILibWebServer_SESSION_TRACKING;_REMOTELOGGING;_REMOTELOGGINGSERVER;MICROSTACK_TLS_DETECT;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;MICROSTACK_PROXY;_WINSERVICE;NOLMSCOMMANDER;WIN32;WIN64;_LINKVM;_DEBUG;_CONSOLE;MEMORY_CHECK;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;__STDC__;_CRT_SECURE_NO_WARNINGS;WINSOCK2;ILibWebServer_SESSION_TRACKING;_REMOTELOGGING;_REMOTELOGGINGSERVER;MICROSTACK_TLS_DETECT;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) true EnableFastChecks MultiThreadedDebug @@ -323,6 +329,9 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + @@ -331,7 +340,7 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) Disabled ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;MICROSTACK_PROXY;_WINSERVICE;NOLMSCOMMANDER;WIN32;WIN64;_LINKVM;_DEBUG;_CONSOLE;MEMORY_CHECK;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;__STDC__;_CRT_SECURE_NO_WARNINGS;WINSOCK2;ILibWebServer_SESSION_TRACKING;_REMOTELOGGING;_REMOTELOGGINGSERVER;MICROSTACK_NOTLS;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;MICROSTACK_PROXY;_WINSERVICE;NOLMSCOMMANDER;WIN32;WIN64;_LINKVM;_DEBUG;_CONSOLE;MEMORY_CHECK;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;__STDC__;_CRT_SECURE_NO_WARNINGS;WINSOCK2;ILibWebServer_SESSION_TRACKING;_REMOTELOGGING;_REMOTELOGGINGSERVER;MICROSTACK_NOTLS;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) true EnableFastChecks MultiThreadedDebug @@ -366,13 +375,16 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + Full true ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;NDEBUG;_WINSERVICE;_CONSOLE;WINSOCK2;MICROSTACK_NO_STDAFX;MICROSTACK_TLS_DETECT;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;_REMOTELOGGING;_REMOTELOGGINGSERVER;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;NDEBUG;_WINSERVICE;_CONSOLE;WINSOCK2;MICROSTACK_NO_STDAFX;MICROSTACK_TLS_DETECT;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;_REMOTELOGGING;_REMOTELOGGINGSERVER;%(PreprocessorDefinitions) MultiThreadedDebug true @@ -409,13 +421,16 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + Full true ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;NDEBUG;_WINSERVICE;_CONSOLE;_LINKVM;WINSOCK2;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_NOTLS;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=3;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;NDEBUG;_WINSERVICE;_CONSOLE;_LINKVM;WINSOCK2;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_NOTLS;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) MultiThreaded true @@ -452,6 +467,9 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + @@ -461,7 +479,7 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) MinSpace true ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;WIN32;WIN64;_WINSERVICE;NDEBUG;_LINKVM;_CONSOLE;MICROSTACK_NO_STDAFX;WINSOCK2;MICROSTACK_TLS_DETECT;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;_REMOTELOGGING;_REMOTELOGGINGSERVER;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;WIN32;WIN64;_WINSERVICE;NDEBUG;_LINKVM;_CONSOLE;MICROSTACK_NO_STDAFX;WINSOCK2;MICROSTACK_TLS_DETECT;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);ILibChain_WATCHDOG_TIMEOUT=600000;DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;_REMOTELOGGING;_REMOTELOGGINGSERVER;%(PreprocessorDefinitions) MultiThreaded true @@ -497,6 +515,9 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + @@ -506,7 +527,7 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) MinSpace true ..\openssl\include;..\;%(AdditionalIncludeDirectories) - MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;WIN64;NDEBUG;_WINSERVICE;_CONSOLE;_LINKVM;WINSOCK2;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_NOTLS;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) + _ARCH_$(PlatformArchitecture);MESH_AGENTID=4;DUK_USE_DATE_NOW_WINDOWS;NOLMSCOMMANDER;MICROSTACK_PROXY;_LINKVM;WIN32;WIN64;NDEBUG;_WINSERVICE;_CONSOLE;_LINKVM;WINSOCK2;MICROSTACK_NO_STDAFX;MICROSTACK_PROXY;MICROSTACK_NOTLS;_MSC_PLATFORM_TOOLSET_$(PlatformToolset);DUK_USE_DEBUGGER_SUPPORT;DUK_USE_INTERRUPT_COUNTER;DUK_USE_DEBUGGER_INSPECT;DUK_USE_DEBUGGER_PAUSE_UNCAUGHT;DUK_USE_DEBUGGER_DUMPHEAP;%(PreprocessorDefinitions) MultiThreaded true @@ -542,6 +563,9 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) $(ProjectDir)dpiaware.manifest %(AdditionalManifestFiles) + + _ARCH_$(PlatformArchitecture);%(PreprocessorDefinitions) + @@ -669,6 +693,12 @@ powershell -ExecutionPolicy Unrestricted $(ProjectDir)prebuild.ps1 $(ProjectDir) + + + + + + diff --git a/meshservice/MeshService.vcxproj.filters b/meshservice/MeshService.vcxproj.filters index 7c40f4550..a4eef3eb2 100644 --- a/meshservice/MeshService.vcxproj.filters +++ b/meshservice/MeshService.vcxproj.filters @@ -20,6 +20,12 @@ {cb187bde-f3b9-48e0-b3fd-f1732a3b3de2} + + {4e67d388-0e2f-479f-848f-cac0c5576346} + + + {a21d9586-6d67-4efa-a44b-403321268b1a} + @@ -360,4 +366,18 @@ + + + Resource Files\x64 + + + Resource Files\x64 + + + Resource Files\ia32 + + + Resource Files\ia32 + + \ No newline at end of file diff --git a/meshservice/MeshService64.rc b/meshservice/MeshService64.rc index 6784abcb7..0a8be3bd2 100644 --- a/meshservice/MeshService64.rc +++ b/meshservice/MeshService64.rc @@ -19,6 +19,48 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US #pragma code_page(1252) +///////////////////////////////////////////////////////////////////////////// +// +// BIN +// + +#if defined(APSTUDIO_INVOKED) || defined(_ARCH_64) +#if defined(APSTUDIO_INVOKED) +IDR_WINPTY_DLL_X64$(_ARCH_64) BIN "x64\\winpty.dll" + +#else +IDR_WINPTY_DLL_X64 BIN "x64\\winpty.dll" + +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(_ARCH_64) +#if defined(APSTUDIO_INVOKED) +IDR_WINPTY_AGENT_EXE_X64$(_ARCH_64) BIN "x64\\winpty-agent.exe" + +#else +IDR_WINPTY_AGENT_EXE_X64 BIN "x64\\winpty-agent.exe" + +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(_ARCH_32) +#if defined(APSTUDIO_INVOKED) +IDR_WINPTY_DLL_IA32$(_ARCH_32) BIN "ia32\\winpty.dll" + +#else +IDR_WINPTY_DLL_IA32 BIN "ia32\\winpty.dll" + +#endif +#endif +#if defined(APSTUDIO_INVOKED) || defined(_ARCH_32) +#if defined(APSTUDIO_INVOKED) +IDR_WINPTY_AGENT_EXE_IA32$(_ARCH_32) BIN "ia32\\winpty-agent.exe" + +#else +IDR_WINPTY_AGENT_EXE_IA32 BIN "ia32\\winpty-agent.exe" + +#endif +#endif + #ifdef APSTUDIO_INVOKED ///////////////////////////////////////////////////////////////////////////// // diff --git a/meshservice/ia32/winpty-agent.exe b/meshservice/ia32/winpty-agent.exe new file mode 100644 index 000000000..221e24f4f Binary files /dev/null and b/meshservice/ia32/winpty-agent.exe differ diff --git a/meshservice/ia32/winpty.dll b/meshservice/ia32/winpty.dll new file mode 100644 index 000000000..782f40f58 Binary files /dev/null and b/meshservice/ia32/winpty.dll differ diff --git a/meshservice/resource.h b/meshservice/resource.h index 15d6231fd..7b1cbd569 100644 Binary files a/meshservice/resource.h and b/meshservice/resource.h differ diff --git a/meshservice/x64/winpty-agent.exe b/meshservice/x64/winpty-agent.exe new file mode 100644 index 000000000..c0eef1a39 Binary files /dev/null and b/meshservice/x64/winpty-agent.exe differ diff --git a/meshservice/x64/winpty.dll b/meshservice/x64/winpty.dll new file mode 100644 index 000000000..0a5178c60 Binary files /dev/null and b/meshservice/x64/winpty.dll differ diff --git a/microscript/ILibDuktape_Commit.h b/microscript/ILibDuktape_Commit.h index 91ffb579a..7f62fbc77 100644 --- a/microscript/ILibDuktape_Commit.h +++ b/microscript/ILibDuktape_Commit.h @@ -1,3 +1,3 @@ -// This file is auto-generated, any edits may be overwritten -#define SOURCE_COMMIT_DATE "2025-Mar-6 21:44:07+0000" -#define SOURCE_COMMIT_HASH "28d67274264e140e0c7a4254ad0e32865d5c4a13" +// This file is auto-generated, any edits may be overwritten +#define SOURCE_COMMIT_DATE "2025-Sep-1 14:28:47+0200" +#define SOURCE_COMMIT_HASH "b08c510a7efea567c3306da88cbb15c92e29f1c1" diff --git a/microscript/ILibDuktape_Polyfills.c b/microscript/ILibDuktape_Polyfills.c index 7196022fb..a624e8173 100644 --- a/microscript/ILibDuktape_Polyfills.c +++ b/microscript/ILibDuktape_Polyfills.c @@ -2598,11 +2598,11 @@ void ILibDuktape_Polyfills_JS_Init(duk_context *ctx) duk_peval_string_noresult(ctx, "addCompressedModule('linux-cpuflags', Buffer.from('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', 'base64'));"); duk_peval_string_noresult(ctx, "addCompressedModule('linux-acpi', Buffer.from('eJx9VVFvm0gQfkfiP8z5Bago5Ny3WHlwHJ8OXWWfQnJV1VbVGga8F7zL7S6xLSv//WYBO7h1ui8G9ttvvvlmZh2/c52ZrPeKl2sD46vxFSTCYAUzqWqpmOFSuI7rfOQZCo05NCJHBWaNMK1ZRj/9Tgj/oNKEhnF0Bb4FjPqtUTBxnb1sYMP2IKSBRiMxcA0FrxBwl2FtgAvI5KauOBMZwpabdRul54hc53PPIFeGEZgRvKa3YggDZqxaoLU2pr6O4+12G7FWaSRVGVcdTscfk9l8kc7fk1p74lFUqDUo/K/hitJc7YHVJCZjK5JYsS1IBaxUSHtGWrFbxQ0XZQhaFmbLFLpOzrVRfNWYM5+O0ijfIYCcYgJG0xSSdAS30zRJQ9f5lDz8uXx8gE/T+/vp4iGZp7C8h9lycZc8JMsFvf0B08Vn+CtZ3IWA5BJFwV2trHqSyK2DmJNdKeJZ+EJ2cnSNGS94RkmJsmElQimfUQnKBWpUG65tFTWJy12n4htu2ibQP2dEQd7F1jzXKRqRWRRUXDS77yyruR+4zqErha119H25+hczk9zBDXgt7L2FeZMO0zvve/iMwmgviOb2YU7xDaooY1XlW54QjGow6A7ZFWUKmcEW7XstZdBzdhGjHAsu8G8lKT2z71lGuqmpwakSoxAO8MyqBq9fVRRWAe6oXjrdi8z34memYtWI2EbIIy2zJzReAC/HYLxomaMTb6/x8Cq18yGjAglDLpyCCcvU5zGTQmDrpX+Ampn1NbwRO4QNGpYzw67PDIWXEE718AdODZSc1FAYz1J4wzPZuhFPwTn6h8N2kSpYVSRGTy5vNqumKKhnbkA0VfUGyMgnaibCtFEjI1MaEVH6QaSplamkX8WpoMPFC7pl2rNRhaKk6+LmBn4PqJZtYo3Qa16YPpcJvPySoUZ88gP4jVrTsxSvym/bh6hQcnMCy9oPLlNiRZN2gCHwIs4Oo2+z5/Yq6eDBz7ALptvVmU7iuoNf+LejV3DRKrtaUxSaCDf8OCe28QXbUN93jF+uvtF47Wv6MEy73xzTprfGHbUqdWr+SP8TH8a3cz8Ij9Nz4dCHtw69Ds5w/WDVGebsZThKNi1rBn3qEUTzYq+ljcybCmmO7URawwRuz66oyf8tuBKP', 'base64'));"); #endif - char* _servicemanager = ILibMemory_Allocate(35773, 0, NULL, NULL); - memcpy_s(_servicemanager + 0, 35772, "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", 16000); - memcpy_s(_servicemanager + 16000, 19772, "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", 16000); - memcpy_s(_servicemanager + 32000, 3772, "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", 3772); - ILibDuktape_AddCompressedModuleEx(ctx, "service-manager", _servicemanager, "2023-01-20T21:07:47.000+00:00"); + char* _servicemanager = ILibMemory_Allocate(37269, 0, NULL, NULL); + memcpy_s(_servicemanager + 0, 37268, "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", 16000); + memcpy_s(_servicemanager + 16000, 21268, "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", 16000); + memcpy_s(_servicemanager + 32000, 5268, "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", 5268); + ILibDuktape_AddCompressedModuleEx(ctx, "service-manager", _servicemanager, "2023-03-03T16:34:44.000+01:00"); free(_servicemanager); duk_peval_string_noresult(ctx, "addCompressedModule('user-sessions', Buffer.from('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', 'base64'), '2022-03-29T11:33:55.000-07:00');"); diff --git a/modules/service-manager.js b/modules/service-manager.js index 76587ca98..d00c427a8 100644 --- a/modules/service-manager.js +++ b/modules/service-manager.js @@ -13,6 +13,14 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ + +var GENERIC_READ = 0x80000000; +var GENERIC_WRITE = 0x40000000; +var CREATE_ALWAYS = 2; +var FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000; +var FILE_ATTRIBUTE_ARCHIVE = 0x00000020; +var INVALID_HANDLE_VALUE = -1; + var promise = require('promise'); var systemd_escape = null; @@ -637,6 +645,15 @@ function serviceManager() this.proxy.CreateMethod('FreeSid'); this.proxy2 = this.GM.CreateNativeProxy('Kernel32.dll'); + this.proxy2.CreateMethod('GetModuleHandleW'); + this.proxy2.CreateMethod('FindResourceW'); + this.proxy2.CreateMethod('LoadResource'); + this.proxy2.CreateMethod('SizeofResource'); + this.proxy2.CreateMethod('LockResource'); + this.proxy2.CreateMethod('FreeResource'); + this.proxy2.CreateMethod('CreateFileW'); + this.proxy2.CreateMethod('WriteFile'); + this.proxy2.CreateMethod('CloseHandle'); this.proxy2.CreateMethod('GetLastError'); this.isAdmin = function isAdmin() { @@ -2325,6 +2342,11 @@ function serviceManager() } console.info1(' Install Path = ' + options.installPath); + + // On Windows, we need to install winpty.dll and winpty-agent.exe along with the executable of the agent + // to ensure that legacy / non-ConPTY remote terminal access works properly. + this.deployWinPtyDependencies(options.installPath); + console.info1(' OpenSCManagerA()'); var servicePath = this.GM.CreateVariable('"' + options.servicePath + '"', { wide: true }); var handle = this.proxy.OpenSCManagerA(0x00, 0x00, 0x0002); @@ -3013,6 +3035,17 @@ function serviceManager() var child = require('child_process').execFile(process.env['windir'] + '\\system32\\cmd.exe', ['/C CHOICE /C Y /N /D Y /T 10 & del "' + servicePath + '"'], { type: 4 }); } } + try + { + // Remove winpty.dll and winpty-agent.exe + var fs = require('fs'); + fs.unlinkSync(service.appWorkingDirectory() + '\\winpty.dll'); + fs.unlinkSync(service.appWorkingDirectory() + '\\winpty-agent.exe'); + } + catch (e) + { + console.info1('Error deleting winpty.dll and winpty-agent.exe'); + } if (this.proxy.DeleteService(service._service) == 0) { throw ('Uninstall Service for: ' + name + ', failed with error: ' + this.proxy2.GetLastError()); @@ -3291,6 +3324,83 @@ function serviceManager() } } + // Grab the WinPTY files from the resources of the executable and copy them to the install path. + this.deployWinPtyDependencies = function deployWinPtyDependencies(installPath) + { + console.info1(' Deploy winpty.dll and winpty-agent.exe'); + + var agentExeHandle = this.proxy2.GetModuleHandleW(0); + var winPtyDllResourceId; + var winPtyAgentExeResourceId; + if (this.GM.PointerSize == 8) { + // 64-Bit Windows + winPtyDllResourceId = 114; // IDR_WINPTY_DLL_X64 in resource.h + winPtyAgentExeResourceId = 115; // IDR_WINPTY_AGENT_EXE_X64 + } else { + // 32-Bit Windows + winPtyDllResourceId = 116; // IDR_WINPTY_DLL_IA32 in resource.h + winPtyAgentExeResourceId = 117; // IDR_WINPTY_AGENT_EXE_IA32 + } + var winPtyDllResource = this.proxy2.FindResourceW( + agentExeHandle, + winPtyDllResourceId, + this.GM.CreateVariable('BIN', { wide: true }) + ); + var winPtyAgentExeResource = this.proxy2.FindResourceW( + agentExeHandle, + winPtyAgentExeResourceId, + this.GM.CreateVariable('BIN', { wide: true }) + ); + this.copyResourceToFilesystem(winPtyDllResource, installPath, 'winpty.dll'); + this.copyResourceToFilesystem(winPtyAgentExeResource, installPath, 'winpty-agent.exe') + + console.info1(' => SUCCESS'); + } + + this.copyResourceToFilesystem = function copyResourceToFilesystem(resource, installPath, fileName) + { + if (resource == 0) { + throw ('Invalid resource: ' + fileName); + } + + var resourceData = this.proxy2.LoadResource(0, resource); + if (resourceData == 0) { + throw ('Unable to load resource: ' + fileName); + } + + var resourceSize = this.proxy2.SizeofResource(0, resource); + var lpResource = this.proxy2.LockResource(resourceData); + if (lpResource == 0) { + this.proxy2.FreeResource(resourceData); + throw ('Unable to retrieve memory pointer to resource: ' + fileName); + } + + var file = this.proxy2.CreateFileW( + this.GM.CreateVariable(installPath + '\\' + fileName, { wide: true }), + GENERIC_READ | GENERIC_WRITE, + 0, + 0, + CREATE_ALWAYS, + FILE_FLAG_SEQUENTIAL_SCAN | FILE_ATTRIBUTE_ARCHIVE, + 0 + ); + + if (file == INVALID_HANDLE_VALUE) { + this.proxy2.FreeResource(resourceData); + throw ('Unable to create file: ' + fileName); + } + + var written = this.GM.CreateVariable(4); + var isFileWritten = this.proxy2.WriteFile(file, lpResource, resourceSize, written, 0); + + this.proxy2.CloseHandle(file); + this.proxy2.FreeResource(resourceData); + + if (!isFileWritten) { + throw ('Unable to write file: ' + fileName); + } + } + this.getServiceType = function getServiceType() { if (this._platform != null) { return (this._platform); } diff --git a/modules/win-terminal.js b/modules/win-terminal.js index 1c6e8e20a..dd924ca17 100644 --- a/modules/win-terminal.js +++ b/modules/win-terminal.js @@ -1,6 +1,4 @@ /* -Copyright 2018-2022 Intel Corporation - Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at @@ -14,708 +12,278 @@ See the License for the specific language governing permissions and limitations under the License. */ -var promise = require('promise'); +var WINPTY_MOUSE_MODE_AUTO = 1; +var WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN = 1; +var GENERIC_WRITE = 0x40000000; +var GENERIC_READ = 0x80000000; +var OPEN_EXISTING = 3 + var duplex = require('stream').Duplex; -var SW_HIDE = 0; -var SW_MINIMIZE = 6; -var STARTF_USESHOWWINDOW = 0x1; -var STD_INPUT_HANDLE = -10; -var STD_OUTPUT_HANDLE = -11; -var EVENT_CONSOLE_CARET = 0x4001; -var EVENT_CONSOLE_END_APPLICATION = 0x4007; -var WINEVENT_OUTOFCONTEXT = 0x000; -var WINEVENT_SKIPOWNPROCESS = 0x0002; -var CREATE_NEW_PROCESS_GROUP = 0x200; -var EVENT_CONSOLE_UPDATE_REGION = 0x4002; -var EVENT_CONSOLE_UPDATE_SIMPLE = 0x4003; -var EVENT_CONSOLE_UPDATE_SCROLL = 0x4004; -var EVENT_CONSOLE_LAYOUT = 0x4005; -var EVENT_CONSOLE_START_APPLICATION = 0x4006; -var KEY_EVENT = 0x1; -var MAPVK_VK_TO_VSC = 0; -var WM_QUIT = 0x12; - -var GM = require('_GenericMarshal'); -var si = GM.CreateVariable(GM.PointerSize == 4 ? 68 : 104); -var pi = GM.CreateVariable(GM.PointerSize == 4 ? 16 : 24); - -si.Deref(0, 4).toBuffer().writeUInt32LE(GM.PointerSize == 4 ? 68 : 104); // si.cb -si.Deref(GM.PointerSize == 4 ? 48 : 64, 2).toBuffer().writeUInt16LE(SW_HIDE | SW_MINIMIZE); // si.wShowWindow -si.Deref(GM.PointerSize == 4 ? 44 : 60, 4).toBuffer().writeUInt32LE(STARTF_USESHOWWINDOW); // si.dwFlags; - -var MSG = GM.CreateVariable(GM.PointerSize == 4 ? 28 : 48); - -function windows_terminal() { +function windows_terminal() +{ this._ObjectID = 'windows_terminal'; - this._user32 = GM.CreateNativeProxy('User32.dll'); - this._user32.CreateMethod('DispatchMessageA'); - this._user32.CreateMethod('GetMessageA'); - this._user32.CreateMethod('MapVirtualKeyA'); - this._user32.CreateMethod('PostThreadMessageA'); - this._user32.CreateMethod('SetWinEventHook'); - this._user32.CreateMethod('ShowWindow'); - this._user32.CreateMethod('TranslateMessage'); - this._user32.CreateMethod('UnhookWinEvent'); - this._user32.CreateMethod('VkKeyScanA'); - this._user32.terminal = this; - - this._kernel32 = GM.CreateNativeProxy('Kernel32.dll'); - this._kernel32.CreateMethod('AllocConsole'); - this._kernel32.CreateMethod('CreateProcessA'); - this._kernel32.CreateMethod('CloseHandle'); - this._kernel32.CreateMethod('FillConsoleOutputAttribute'); - this._kernel32.CreateMethod('FillConsoleOutputCharacterA'); - this._kernel32.CreateMethod('GetConsoleScreenBufferInfo'); - this._kernel32.CreateMethod('GetConsoleWindow'); - this._kernel32.CreateMethod('GetLastError'); - this._kernel32.CreateMethod('GetStdHandle'); - this._kernel32.CreateMethod('GetThreadId'); - this._kernel32.CreateMethod('ReadConsoleOutputA'); - this._kernel32.CreateMethod('SetConsoleCursorPosition'); - this._kernel32.CreateMethod('SetConsoleScreenBufferSize'); - this._kernel32.CreateMethod('SetConsoleWindowInfo'); - this._kernel32.CreateMethod('TerminateProcess'); - this._kernel32.CreateMethod('WaitForSingleObject'); - this._kernel32.CreateMethod('WriteConsoleInputA'); - - var currentX = 0; - var currentY = 0; - - this._scrx = 0; - this._scry = 0; - - this.SendCursorUpdate = function () { - var newCsbi = GM.CreateVariable(22); + this.Create = function Create(path, width, height) + { + if (!width) { width = 80; } + if (!height) { height = 25; } + + var GM = require('_GenericMarshal'); + + // Register all required WinPTY API functions. + var winptyDll = GM.CreateNativeProxy('winpty.dll'); + winptyDll.CreateMethod('winpty_config_new'); + winptyDll.CreateMethod('winpty_config_set_initial_size'); + winptyDll.CreateMethod('winpty_config_set_mouse_mode'); + winptyDll.CreateMethod('winpty_config_set_agent_timeout'); + winptyDll.CreateMethod('winpty_open'); + winptyDll.CreateMethod('winpty_config_free'); + winptyDll.CreateMethod('winpty_agent_process'); + winptyDll.CreateMethod('winpty_conin_name'); + winptyDll.CreateMethod('winpty_conout_name'); + winptyDll.CreateMethod('winpty_conerr_name'); + winptyDll.CreateMethod('winpty_spawn_config_new'); + winptyDll.CreateMethod('winpty_spawn'); + winptyDll.CreateMethod('winpty_spawn_config_free'); + winptyDll.CreateMethod('winpty_set_size'); + winptyDll.CreateMethod('winpty_free'); - if (this._kernel32.GetConsoleScreenBufferInfo(this._stdoutput, newCsbi).Val == 0) { return; } - if (newCsbi.Deref(4, 2).toBuffer().readUInt16LE() != this.currentX || newCsbi.Deref(6, 2).toBuffer().readUInt16LE() != this.currentY) - { - // - // Reference for CONSOLE_SCREEN_BUFFER_INFO can be found at: - // https://learn.microsoft.com/en-us/windows/console/console-screen-buffer-info-str - // - - this.currentX = newCsbi.Deref(4, 2).toBuffer().readUInt16LE(); - this.currentY = newCsbi.Deref(6, 2).toBuffer().readUInt16LE(); - } - } + // Register all required Kernel32 API functions. + var kernel32Dll = GM.CreateNativeProxy('kernel32.dll'); + kernel32Dll.CreateMethod('CreateFileW'); + kernel32Dll.CreateMethod('GetProcessId'); + kernel32Dll.CreateMethod('ReadFile'); + kernel32Dll.CreateMethod('WriteFile'); + kernel32Dll.CreateMethod('CancelIoEx'); + kernel32Dll.CreateMethod('CloseHandle'); - this.ClearScreen = function () - { - // - // Reference for CONSOLE_SCREEN_BUFFER_INFO can be found at: - // https://learn.microsoft.com/en-us/windows/console/console-screen-buffer-info-str // - - // - // Reference for GetConsoleScreenBufferInfo can be found at: - // https://learn.microsoft.com/en-us/windows/console/getconsolescreenbufferinfo + // Reference for WinPTY can be found at: + // https://github.com/rprichard/winpty + // https://github.com/rprichard/winpty/blob/0.4.3/src/include/winpty.h // - // - // Reference for FillConsoleOutputCharacter can be found at: - // https://learn.microsoft.com/en-us/windows/console/fillconsoleoutputcharacter - // + // Allocate a WinPTY config. + var config = winptyDll.winpty_config_new( + 0, // [in] Agent flags + 0 // [out, optional] Config error object + ); - // - // Reference for FillConsoleOutputAttribute can be found at: - // https://learn.microsoft.com/en-us/windows/console/fillconsoleoutputattribute - // + // Check for failure. + if (config.Val == 0) { + throw ('winpty_config_new failed'); + } - // - // Reference for SetConsoleCursorPosition can be found at: - // https://learn.microsoft.com/en-us/windows/console/setconsolecursorposition - // + // Set initial terminal size, mouse mode and agent timeout. + winptyDll.winpty_config_set_initial_size(config, width, height); + winptyDll.winpty_config_set_mouse_mode(config, WINPTY_MOUSE_MODE_AUTO); + // Amount of time to wait for the agent to startup and to wait for any given agent RPC request. + winptyDll.winpty_config_set_agent_timeout(config, 1000); + + // Start the agent. + // This process will connect to the agent over a control pipe, + // and the agent will open data pipes (e.g. CONIN and CONOUT). + var winpty = winptyDll.winpty_open( + config, // [in] WinPTY config + 0 // [out, optional] Error object + ); + + // Free the config object after passing it to winpty_open. + winptyDll.winpty_config_free(config); + + // Check for failure. + if (winpty.Val == 0) { + throw ('winpty_open failed'); + } - // - // Reference for SetConsoleWindowInfo can be fount at: - // https://learn.microsoft.com/en-us/windows/console/setconsolewindowinfo - // + // Get a handle to the agent process. + // This value is valid for the lifetime of the winpty_t object. + // Do not close it. + var agentProcess = winptyDll.winpty_agent_process(winpty); + + // Determine the names of named pipes used for terminal I/O. + // Each input or output direction uses a different half-duplex pipe. + // The agent creates these pipes, and the client can connect to them + // using ordinary I/O methods. + // The strings are freed when the winpty_t object is freed. + var coninPipeName = winptyDll.winpty_conin_name(winpty); + var conoutPipeName = winptyDll.winpty_conout_name(winpty); + var conerrPipeName = winptyDll.winpty_conerr_name(winpty); + + // Open handles to the terminal pipes. + var conin = kernel32Dll.CreateFileW(coninPipeName, GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); + var conout = kernel32Dll.CreateFileW(conoutPipeName, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0); + var conerr = kernel32Dll.CreateFileW(conerrPipeName, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0); + + // Allocate a WinPTY spawn config. + var spawnConfig = winptyDll.winpty_spawn_config_new( + WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, // [in] Spawn flags + GM.CreateVariable(path, { wide: true }), // [in, optional] App name + 0, // [in, optional] Command line arguments + 0, // [in, optional] Current working directory + 0, // [in, optional] Environment block passed to CreateProcess + 0 // [out, optional] Error object + ); + + // Check for failure. + if (spawnConfig.Val == 0) { + kernel32Dll.CloseHandle(conout); + kernel32Dll.CloseHandle(conerr); + kernel32Dll.CloseHandle(conin); + winptyDll.winpty_free(winpty); + throw ('winpty_spawn_config_new failed'); + } - var CONSOLE_SCREEN_BUFFER_INFO = GM.CreateVariable(22); - if (this._kernel32.GetConsoleScreenBufferInfo(this._stdoutput, CONSOLE_SCREEN_BUFFER_INFO).Val == 0) { return; } - - var coordScreen = GM.CreateVariable(4); - var dwConSize = CONSOLE_SCREEN_BUFFER_INFO.Deref(0, 2).toBuffer().readUInt16LE(0) * CONSOLE_SCREEN_BUFFER_INFO.Deref(2, 2).toBuffer().readUInt16LE(0); - var cCharsWritten = GM.CreateVariable(4); - - // Fill the entire screen with blanks. - if (this._kernel32.FillConsoleOutputCharacterA(this._stdoutput, 32, dwConSize, coordScreen.Deref(0, 4).toBuffer().readUInt32LE(), cCharsWritten).Val == 0) { return; } - - // Get the current text attribute. - if (this._kernel32.GetConsoleScreenBufferInfo(this._stdoutput, CONSOLE_SCREEN_BUFFER_INFO).Val == 0) { return; } - - // Set the buffer's attributes accordingly. - if (this._kernel32.FillConsoleOutputAttribute(this._stdoutput, CONSOLE_SCREEN_BUFFER_INFO.Deref(8, 2).toBuffer().readUInt16LE(0), dwConSize, coordScreen.Deref(0, 4).toBuffer().readUInt32LE(), cCharsWritten).Val == 0) { return; } - - // Put the cursor at its home coordinates. - this._kernel32.SetConsoleCursorPosition(this._stdoutput, coordScreen.Deref(0, 4).toBuffer().readUInt32LE()); - - // Put the window to top-left. - var rect = GM.CreateVariable(8); - var srWindow = CONSOLE_SCREEN_BUFFER_INFO.Deref(10, 8).toBuffer(); - rect.Deref(4, 2).toBuffer().writeUInt16LE(srWindow.readUInt16LE(4) - srWindow.readUInt16LE(0)); - rect.Deref(6, 2).toBuffer().writeUInt16LE(srWindow.readUInt16LE(6) - srWindow.readUInt16LE(2)); - - this._kernel32.SetConsoleWindowInfo(this._stdoutput, 1, rect); - } + var process = GM.CreatePointer(); + // Spawn the new process. + var spawnSuccess = winptyDll.winpty_spawn( + winpty, // [in] WinPTY object + spawnConfig, // [in] Spawn config + process, // [out, optional] Process + 0, // [out, optional] Thread + 0, // [out, optional] Value of GetLastError if CreateProcess fails. + 0 // [out, optional] Error object + ); - // This does a rudimentary check if the platform is capable of PowerShell - this.PowerShellCapable = function() - { - if (require('os').arch() == 'x64') - { - return (require('fs').existsSync(process.env['windir'] + '\\SysWow64\\WindowsPowerShell\\v1.0\\powershell.exe')); + // Free the spawn config object after passing it to winpty_spawn. + winptyDll.winpty_spawn_config_free(spawnConfig); + + // Check for failure. + if (!spawnSuccess) { + kernel32Dll.CloseHandle(conout); + kernel32Dll.CloseHandle(conerr); + kernel32Dll.CloseHandle(conin); + winptyDll.winpty_free(winpty); + throw ('winpty_spawn failed'); } - else - { - return (require('fs').existsSync(process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')); - } - } - // Starts a Legacy Windows Terminal Session - this.StartEx = function Start(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT, terminalTarget) - { - // The older windows terminal does not support - CONSOLE_SCREEN_WIDTH = 80; - CONSOLE_SCREEN_HEIGHT = 25; - - if (this._stream != null) - { - throw ('Concurrent terminal sessions are not supported on Windows.'); - } - this.stopping = null; - if (this._kernel32.GetConsoleWindow().Val == 0) { - if (this._kernel32.AllocConsole().Val == 0) { - throw ('AllocConsole failed with: ' + this._kernel32.GetLastError().Val); - } - } - - this._stdinput = this._kernel32.GetStdHandle(STD_INPUT_HANDLE); - this._stdoutput = this._kernel32.GetStdHandle(STD_OUTPUT_HANDLE); - this._connected = false; - - // Coord structure can be found at: https://learn.microsoft.com/en-us/windows/console/coord-str - var coordScreen = GM.CreateVariable(4); - coordScreen.Deref(0, 2).toBuffer().writeUInt16LE(CONSOLE_SCREEN_WIDTH); - coordScreen.Deref(2, 2).toBuffer().writeUInt16LE(CONSOLE_SCREEN_HEIGHT); - - var rect = GM.CreateVariable(8); - rect.Deref(4, 2).toBuffer().writeUInt16LE(CONSOLE_SCREEN_WIDTH - 1); - rect.Deref(6, 2).toBuffer().writeUInt16LE(CONSOLE_SCREEN_HEIGHT - 1); - - // - // Reference for SetConsoleWindowInfo can be found at: - // https://learn.microsoft.com/en-us/windows/console/setconsolewindowinfo - // - if (this._kernel32.SetConsoleWindowInfo(this._stdoutput, 1, rect).Val == 0) - { - throw ('Failed to set Console Screen Size'); - } + var processId = kernel32Dll.GetProcessId(process.Deref()); // - // Reference for SetConsoleScreenBufferSize can be found at: - // https://learn.microsoft.com/en-us/windows/console/setconsolescreenbuffersize + // Create a Stream Object, to be able to read/write data to WinPTY. // - if (this._kernel32.SetConsoleScreenBufferSize(this._stdoutput, coordScreen.Deref(0, 4).toBuffer().readUInt32LE()).Val == 0) - { - throw ('Failed to set Console Buffer Size'); - } - - // Hide the console window - this._user32.ShowWindow(this._kernel32.GetConsoleWindow().Val, SW_HIDE); - - this.ClearScreen(); - this._hookThread(terminalTarget).then(function () + var ret = { _winpty: winpty, _input: conin, _output: conout, _error: conerr, kernel32Dll: kernel32Dll }; + ret._process = process; + ret._pid = processId; + var ds = new duplex( { - // Hook Ready - this.terminal.StartCommand(this.userArgs[0]); - }, console.log); - this._stream = new duplex( + 'write': function (chunk, flush) { - 'write': function (chunk, flush) - { - if (!this.terminal.connected) - { - //console.log('_write: ' + chunk); - if (!this._promise.chunk) - { - this._promise.chunk = []; - } - if (typeof (chunk) == 'string') - { - this._promise.chunk.push(chunk); - } else - { - this._promise.chunk.push(Buffer.alloc(chunk.length)); - chunk.copy(this._promise.chunk.peek()); - } - this._promise.chunk.peek().flush = flush; - this._promise.then(function () - { - var buf; - while (this.chunk.length > 0) - { - buf = this.chunk.shift(); - this.terminal._WriteBuffer(buf); - buf.flush(); - } - }); - } - else - { - //console.log('writeNOW: ' + chunk); - this.terminal._WriteBuffer(chunk); - flush(); - } - return (true); - }, - 'final': function (flush) + var written = require('_GenericMarshal').CreateVariable(4); + this.terminal.kernel32Dll.WriteFile(this.terminal._input, require('_GenericMarshal').CreateVariable(chunk), chunk.length, written, 0); + flush(); + return true; + }, + 'final': function (flush) + { + if (this.terminal._process) { - var p = this.terminal._stop(); - p.__flush = flush; - p.then(function () { this.__flush(); }); + this.terminal._process = null; + winptyDll.winpty_free(this.terminal._winpty); } - }); - this._stream.terminal = this; - this._stream._promise = new promise(function (res, rej) { this._res = res; this._rej = rej; }); - this._stream._promise.terminal = this; - this._stream.prependOnceListener('end', function () - { - this.terminal._stream = null; - }); - return (this._stream); - }; - this.Start = function Start(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT) - { - return (this.StartEx(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT, process.env['windir'] + '\\System32\\cmd.exe')); - } - this.StartPowerShell = function StartPowerShell(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT) - { - if (require('os').arch() == 'x64') - { - if (require('fs').existsSync(process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')) - { - return (this.StartEx(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT, process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')); - } - else - { - return (this.StartEx(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT, process.env['windir'] + '\\SysWow64\\WindowsPowerShell\\v1.0\\powershell.exe')); - } - } - else - { - return (this.StartEx(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT, process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')); - } - } - - this._stop = function () { - if (this.stopping) { return (this.stopping); } - //console.log('Stopping Terminal...'); - this._ConsoleWinEventProc.removeAllListeners('GlobalCallback'); - this.stopping = new promise(function (res, rej) { this._res = res; this._rej = rej; }); - - var threadID = this._kernel32.GetThreadId(this._user32.SetWinEventHook.async.thread()).Val; - this._user32.PostThreadMessageA(threadID, WM_QUIT, 0, 0); - this._stream.emit('end'); - return (this.stopping); - } - - // - // This function uses the SetWinEventHook() method, so we can hook - // All events between EVENT_CONSOLE_CARET and EVENT_CONSOLE_END_APPLICATION - // - this._hookThread = function () - { - // - // Reference for SetWinEventHook() can be found at: - // https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwineventhook - // - var ret = new promise(function (res, rej) { this._res = res; this._rej = rej; }); - ret.userArgs = []; - for (var a in arguments) - { - ret.userArgs.push(arguments[a]); - } - ret.terminal = this; - this._ConsoleWinEventProc = GM.GetGenericGlobalCallback(7); - this._ConsoleWinEventProc.terminal = this; - var p = this._user32.SetWinEventHook.async(EVENT_CONSOLE_CARET, EVENT_CONSOLE_END_APPLICATION, 0, this._ConsoleWinEventProc, 0, 0, WINEVENT_OUTOFCONTEXT | WINEVENT_SKIPOWNPROCESS); - p.ready = ret; - p.terminal = this; - p.then(function (hwinEventHook) - { - if (hwinEventHook.Val == 0) - { - this.ready._rej('Error calling SetWinEventHook'); - } else - { - this.terminal.hwinEventHook = hwinEventHook; - this.ready._res(); - this.terminal._GetMessage(); + flush(); } }); - + // - // This is the WINEVENTPROC callback for the WinEventHook we set + // The ProcessInfo object is signaled when the process exits // - this._ConsoleWinEventProc.on('GlobalCallback', function (hhook, dwEvent, hwnd, idObject, idChild, idEventThread, swmsEventTime) + ds._obj = ret; + ret._waiter = require('DescriptorEvents').addDescriptor(process.Deref()); + ret._waiter.ds = ds; + ret._waiter._obj = ret; + ret._waiter.on('signaled', function () { - // - // Reference for WINEVENTPROC can be found at: - // https://learn.microsoft.com/en-us/windows/win32/api/winuser/nc-winuser-wineventproc - // - if (!this.terminal.hwinEventHook || this.terminal.hwinEventHook.Val != hhook.Val) { return; } - var buffer = null; - - // - // Reference for Console WinEvents can be found at: - // https://learn.microsoft.com/en-us/windows/console/console-winevents - // - - switch (dwEvent.Val) - { - case EVENT_CONSOLE_CARET: - // The console caret has moved - break; - case EVENT_CONSOLE_UPDATE_REGION: - // More than one character has changed - if (!this.terminal.connected) { - this.terminal.connected = true; - this.terminal._stream._promise._res(); - } - if (this.terminal._scrollTimer == null) { - buffer = this.terminal._GetScreenBuffer(LOWORD(idObject.Val), HIWORD(idObject.Val), LOWORD(idChild.Val), HIWORD(idChild.Val)); - //console.log('UPDATE REGION: [Left: ' + LOWORD(idObject.Val) + ' Top: ' + HIWORD(idObject.Val) + ' Right: ' + LOWORD(idChild.Val) + ' Bottom: ' + HIWORD(idChild.Val) + ']'); - this.terminal._SendDataBuffer(buffer); - } - break; - case EVENT_CONSOLE_UPDATE_SIMPLE: - // A single character has changed - //console.log('UPDATE SIMPLE: [X: ' + LOWORD(idObject.Val) + ' Y: ' + HIWORD(idObject.Val) + ' Char: ' + LOWORD(idChild.Val) + ' Attr: ' + HIWORD(idChild.Val) + ']'); - var simplebuffer = { data: [ Buffer.alloc(1, LOWORD(idChild.Val)) ], attributes: [ HIWORD(idChild.Val) ], width: 1, height: 1, x: LOWORD(idObject.Val), y: HIWORD(idObject.Val) }; - this.terminal._SendDataBuffer(simplebuffer); - break; - case EVENT_CONSOLE_UPDATE_SCROLL: - // The console has scrolled - //console.log('UPDATE SCROLL: [dx: ' + idObject.Val + ' dy: ' + idChild.Val + ']'); - this.terminal._SendScroll(idObject.Val, idChild.Val); - break; - case EVENT_CONSOLE_LAYOUT: - // The console layout has changed. - //console.log('CONSOLE_LAYOUT'); - //snprintf( Buf, 512, "Event Console LAYOUT!\r\n"); - //SendLayout(); - break; - case EVENT_CONSOLE_START_APPLICATION: - // A new console process has started - //console.log('START APPLICATION: [PID: ' + idObject.Val + ' CID: ' + idChild.Val + ']'); - //snprintf( Buf, 512, "Event Console START APPLICATION!\r\nProcess ID: %d - Child ID: %d\r\n\r\n", (int)idObject, (int)idChild); - //SendConsoleEvent(dwEvent, idObject, idChild); - break; - case EVENT_CONSOLE_END_APPLICATION: - // A console process has exited - if (idObject.Val == this.terminal._hProcessID) - { - //console.log('END APPLICATION: [PID: ' + idObject.Val + ' CID: ' + idChild.Val + ']'); - this.terminal._hProcess = null; - this.terminal._stop().then(function () { console.log('STOPPED'); }); - } - break; - default: - //snprintf(Buf, 512, "unknown console event.\r\n"); - console.log('Unknown event: ' + dwEvent.Val); - break; - } + kernel32Dll.CancelIoEx(this._obj._output, 0); - //mbstowcs_s(&l, wBuf, Buf, 512); - //OutputDebugString(wBuf); + // Child process has exited + this.ds.push(null); - }); - return (ret); - } - - // Retrieves a message from the calling thread's message queue - this._GetMessage = function () - { - // - // Reference for GetMessage() can be found at: - // https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getmessage - // - - // - // Reference for TranslateMessage() can be found at: - // https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-translatemessage - // - - // - // Reference for DispatchMessage() can be found at: - // https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-dispatchmessage - // + kernel32Dll.CloseHandle(this._obj._input); + kernel32Dll.CloseHandle(this._obj._output); + kernel32Dll.CloseHandle(this._obj._error); - if (this._user32.abort) { console.log('aborting loop'); return; } - this._user32.GetMessageA.async(this._user32.SetWinEventHook.async, MSG, 0, 0, 0).then(function (ret) - { - //console.log('GetMessage Response'); - if (ret.Val != 0) - { - if (ret.Val == -1) - { - // handle the error and possibly exit - } - else - { - // Translates virtual-key messages into character messages - //console.log('TranslateMessage'); - this.nativeProxy._user32.TranslateMessage.async(this.nativeProxy.user32.SetWinEventHook.async, MSG).then(function () - { - // Dispatches a message to a window procedure - //console.log('DispatchMessage'); - this.nativeProxy._user32.DispatchMessageA.async(this.nativeProxy.user32.SetWinEventHook.async, MSG).then(function () - { - this.nativeProxy.terminal._GetMessage(); - }, console.log); - }, console.log); - } - } else - { - this.nativeProxy.UnhookWinEvent.async(this.nativeProxy.terminal._user32.SetWinEventHook.async, this.nativeProxy.terminal.hwinEventHook) - .then(function () - { - if (this.nativeProxy.terminal._hProcess == null) { return; } - - this.nativeProxy.terminal.stopping._res(); - if (this.nativeProxy.terminal._kernel32.TerminateProcess(this.nativeProxy.terminal._hProcess, 1067).Val == 0) - { - var e = this.nativeProxy.terminal._kernel32.GetLastError().Val; - console.log('Unable to kill Terminal Process, error: ' + e); - } - this.nativeProxy.terminal.stopping = null; - }, function (err) - { - console.log('REJECTED_UnhookWinEvent: ' + err); - }); + if (this._obj._process) { + this._obj._process = null; + winptyDll.winpty_free(this._obj._winpty); } - }, function (err) - { - // Get Message Failed - console.log('REJECTED_GETMessage: ' + err); }); - } - - this._WriteBuffer = function (buf) - { - for (var i = 0; i < buf.length; ++i) + ds.resizeTerminal = function (w, h) { - if (typeof (buf) == 'string') - { - this._WriteCharacter(buf.charCodeAt(i), false); - } else - { - this._WriteCharacter(buf[i], false); + var resizeSuccess = winptyDll.winpty_set_size( + winpty, // [in] WinPTY object + w, // [in] Columns + h, // [in] Rows + 0 // [out, optional] Error object + ); + + if (!resizeSuccess) { + console.log('winpty_set_size failed'); } - } - } - this._WriteCharacter = function (key, bControlKey) - { - // - // Reference for WriteConsoleInput() can be found at: - // https://learn.microsoft.com/en-us/windows/console/writeconsoleinput - // - - // - // Reference for INPUT_RECORD can be found at: - // https://learn.microsoft.com/en-us/windows/console/input-record-str - // - - var rec = GM.CreateVariable(20); - rec.Deref(0, 2).toBuffer().writeUInt16LE(KEY_EVENT); // rec.EventType - rec.Deref(4, 4).toBuffer().writeUInt16LE(1); // rec.Event.KeyEvent.bKeyDown - rec.Deref(16, 4).toBuffer().writeUInt32LE(bControlKey); // rec.Event.KeyEvent.dwControlKeyState - rec.Deref(14, 1).toBuffer()[0] = key; // rec.Event.KeyEvent.uChar.AsciiChar - rec.Deref(8, 2).toBuffer().writeUInt16LE(1); // rec.Event.KeyEvent.wRepeatCount - rec.Deref(10, 2).toBuffer().writeUInt16LE(this._user32.VkKeyScanA(key).Val); // rec.Event.KeyEvent.wVirtualKeyCode - rec.Deref(12, 2).toBuffer().writeUInt16LE(this._user32.MapVirtualKeyA(this._user32.VkKeyScanA(key).Val, MAPVK_VK_TO_VSC).Val); + }; - var dwWritten = GM.CreateVariable(4); - if (this._kernel32.WriteConsoleInputA(this._stdinput, rec, 1, dwWritten).Val == 0) { return (false); } + ds.terminal = ret; + ds._rpbuf = GM.CreateVariable(4096); + ds._rpbufRead = GM.CreateVariable(4); + ds.__read = function __read() + { + // Asyncronously read data from WinPTY + this._rp = this.terminal.kernel32Dll.ReadFile.async(this.terminal._output, this._rpbuf, this._rpbuf._size, this._rpbufRead, 0); + this._rp.then(function () + { + var len = this.parent._rpbufRead.toBuffer().readUInt32LE(); + if (len <= 0) { return; } - rec.Deref(4, 4).toBuffer().writeUInt16LE(0); // rec.Event.KeyEvent.bKeyDown - return (this._kernel32.WriteConsoleInputA(this._stdinput, rec, 1, dwWritten).Val != 0); + this.parent.push(this.parent._rpbuf.toBuffer().slice(0, len)); + this.parent.__read(); + }); + this._rp.parent = this; + }; + ds.__read(); + return ds; } - - // Get the current visible screen buffer - this._GetScreenBuffer = function (sx, sy, ex, ey) - { - // - // Reference for GetConsoleScreenBufferInfo() can be found at: - // https://learn.microsoft.com/en-us/windows/console/getconsolescreenbufferinfo - // - // - // Reference for ReadConsoleOutput() can be found at: - // https://learn.microsoft.com/en-us/windows/console/readconsoleoutput - // - - var info = GM.CreateVariable(22); - if (this._kernel32.GetConsoleScreenBufferInfo(this._stdoutput, info).Val == 0) { throw ('Error getting screen buffer info'); } - - var nWidth = info.Deref(14, 2).toBuffer().readUInt16LE() - info.Deref(10, 2).toBuffer().readUInt16LE() + 1; - var nHeight = info.Deref(16, 2).toBuffer().readUInt16LE() - info.Deref(12, 2).toBuffer().readUInt16LE() + 1; - - if (arguments[3] == null) - { - // Use Default Parameters - sx = 0; - sy = 0; - ex = nWidth - 1; - ey = nHeight - 1; - } else + // This evaluates whether or not the powershell binary exists + this.PowerShellCapable = function () + { + if (require('os').arch() == 'x64') { - if (this._scrx != 0) { sx += this._scrx; ex += this._scrx; } - if (this._scry != 0) { sy += this._scry; ey += this._scry; } - this._scrx = this._scry = 0; + return (require('fs').existsSync(process.env['windir'] + '\\SysWow64\\WindowsPowerShell\\v1.0\\powershell.exe')); } - - var nBuffer = GM.CreateVariable((ex - sx + 1) * (ey - sy + 1) * 4); - var size = GM.CreateVariable(4); - size.Deref(0, 2).toBuffer().writeUInt16LE(ex - sx + 1, 0); - size.Deref(2, 2).toBuffer().writeUInt16LE(ey - sy + 1, 0); - - var startCoord = GM.CreateVariable(4); - startCoord.Deref(0, 2).toBuffer().writeUInt16LE(0, 0); - startCoord.Deref(2, 2).toBuffer().writeUInt16LE(0, 0); - - var region = GM.CreateVariable(8); - region.buffer = region.toBuffer(); - region.buffer.writeUInt16LE(sx, 0); - region.buffer.writeUInt16LE(sy, 2); - region.buffer.writeUInt16LE(ex, 4); - region.buffer.writeUInt16LE(ey, 6); - - if (this._kernel32.ReadConsoleOutputA(this._stdoutput, nBuffer, size.Deref(0, 4).toBuffer().readUInt32LE(), startCoord.Deref(0, 4).toBuffer().readUInt32LE(), region).Val == 0) + else { - throw ('Unable to read Console Output'); + return (require('fs').existsSync(process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')); } + } - // Lets convert the buffer into something simpler - //var retVal = { data: Buffer.alloc((dw - dx + 1) * (dh - dy + 1)), attributes: Buffer.alloc((dw - dx + 1) * (dh - dy + 1)), width: dw - dx + 1, height: dh - dy + 1, x: dx, y: dy }; - - var retVal = { data: [], attributes: [], width: ex - sx + 1, height: ey - sy + 1, x: sx, y: sy }; - var x, y, line, ifo, tmp, lineWidth = ex - sx + 1; + // Start WinPTY with the Command Prompt + this.Start = function Start(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT) + { + return (this.Create(process.env['windir'] + '\\System32\\cmd.exe', CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT)); + } - for (y = 0; y <= (ey - sy) ; ++y) + // Start WinPTY with PowerShell + this.StartPowerShell = function StartPowerShell(CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT) + { + if (require('os').arch() == 'x64') { - retVal.data.push(Buffer.alloc(lineWidth)); - retVal.attributes.push(Buffer.alloc(lineWidth)); - - line = nBuffer.Deref(y * lineWidth * 4, lineWidth * 4).toBuffer(); - for (x = 0; x < lineWidth; ++x) + if (require('fs').existsSync(process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe')) { - retVal.data.peek()[x] = line[x * 4]; - retVal.attributes.peek()[x] = line[2 + (x * 4)]; + return (this.Create(process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe', CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT)); } - } - - return (retVal); - } - - this._SendDataBuffer = function (data) - { - // { data, attributes, width, height, x, y } - if (this._stream != null) - { - var dy, line, attr; - for (dy = 0; dy < data.height; ++dy) + else { - line = data.data[dy]; - attr = data.attributes[dy]; - line.s = line.toString(); - - //line = data.data.slice(data.width * dy, (data.width * dy) + data.width); - //attr = data.attributes.slice(data.width * dy, (data.width * dy) + data.width); - this._stream.push(TranslateLine(data.x + 1, data.y + dy + 1, line, attr)); + return (this.Create(process.env['windir'] + '\\SysWow64\\WindowsPowerShell\\v1.0\\powershell.exe', CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT)); } } - } - - this._SendScroll = function _SendScroll(dx, dy) - { - // - // Reference for GetConsoleScreenBufferInfo() can be found at: - // https://learn.microsoft.com/en-us/windows/console/getconsolescreenbufferinfo - // - - if (this._scrollTimer || this._stream == null) { return; } - - var info = GM.CreateVariable(22); - if (this._kernel32.GetConsoleScreenBufferInfo(this._stdoutput, info).Val == 0) { throw ('Error getting screen buffer info'); } - - var nWidth = info.Deref(14, 2).toBuffer().readUInt16LE() - info.Deref(10, 2).toBuffer().readUInt16LE() + 1; - var nHeight = info.Deref(16, 2).toBuffer().readUInt16LE() - info.Deref(12, 2).toBuffer().readUInt16LE() + 1; - - this._stream.push(GetEsc('H', [nHeight - 1, 0])); - for (var i = 0; i > nHeight; ++i) { this._stream.push(Buffer.from('\r\n')); } - - var buffer = this._GetScreenBuffer(0, 0, nWidth - 1, nHeight - 1); - this._SendDataBuffer(buffer); - - this._scrollTimer = setTimeout(function (self, nw, nh) { - var buffer = self._GetScreenBuffer(0, 0, nw - 1, nh - 1); - self._SendDataBuffer(buffer); - self._scrollTimer = null; - }, 250, this, nWidth, nHeight); - } - - this.StartCommand = function StartCommand(target) { - if (this._kernel32.CreateProcessA(GM.CreateVariable(target), 0, 0, 0, 1, CREATE_NEW_PROCESS_GROUP, 0, 0, si, pi).Val == 0) + else { - console.log('Error Spawning CMD'); - return; + return (this.Create(process.env['windir'] + '\\System32\\WindowsPowerShell\\v1.0\\powershell.exe', CONSOLE_SCREEN_WIDTH, CONSOLE_SCREEN_HEIGHT)); } - - this._kernel32.CloseHandle(pi.Deref(GM.PointerSize, GM.PointerSize).Deref()); // pi.hThread - this._hProcess = pi.Deref(0, GM.PointerSize).Deref(); // pi.hProcess - this._hProcessID = pi.Deref(GM.PointerSize == 4 ? 8 : 16, 4).toBuffer().readUInt32LE(); // pi.dwProcessId - //console.log('Ready => hProcess: ' + this._hProcess._ptr + ' PID: ' + this._hProcessID); } } -function LOWORD(val) { return (val & 0xFFFF); } -function HIWORD(val) { return ((val >> 16) & 0xFFFF); } -function GetEsc(op, args) { return (Buffer.from('\x1B[' + args.join(';') + op)); } -function MeshConsole(msg) { require('MeshAgent').SendCommand({ "action": "msg", "type": "console", "value": JSON.stringify(msg) }); } -function TranslateLine(x, y, data, attributes) +if (process.platform == 'win32') { - var i, fcolor, bcolor, rcolor, fbright, bbright, lastAttr, fc, bc, rc, fb, bb, esc = [], output = [GetEsc('H', [y, x])]; - if (typeof attributes == 'number') { attributes = [attributes]; } // If we get a single attribute, turn it into an array. - - for (i = 0; i < data.length; i++) - { - if (lastAttr != attributes[i]) - { // To boost performance, if the attribute is the same as the last one, skip this entire part. - fc = (attributes[i] & 0x0007); - fc = ((fc & 0x0001) << 2) + (fc & 0x0002) + ((fc & 0x0004) >> 2); // Foreground color - bc = (attributes[i] & 0x0070) >> 4; - bc = ((bc & 0x0001) << 2) + (bc & 0x0002) + ((bc & 0x0004) >> 2); // Background color - rc = (attributes[i] & 0x4000); // Reverse color set - fb = (attributes[i] & 0x0008) >> 3; // Bright foreground set - bb = (attributes[i] & 0x0080); // Bright background set - - if (rc != rcolor) { if (rc != 0) { esc.push(7); } else { esc.push(0); fcolor = 7; bcolor = 0; fbright = 0; bbright = 0; } rcolor = rc; } // Reverse Color - if (fc != fcolor) { esc.push(fc + 30); fcolor = fc; } // Set the foreground color if needed - if (bc != bcolor) { esc.push(bc + 40); bcolor = bc; } // Set the background color if needed - if (fb != fbright) { esc.push(2 - fb); fbright = fb; } // Set the bright foreground color if needed - if (bb != bbright) { if (bb == 0) { esc.push(bcolor + 40); } else { esc.push(bcolor + 100); bbright = bb; } } // Set bright Background color if needed - - if (esc.length > 0) { output.push(GetEsc('m', esc)); esc = []; } - lastAttr = attributes[i]; - } - output.push(Buffer.from(String.fromCharCode(data[i]))); - } - - return Buffer.concat(output); + module.exports = new windows_terminal(); } - -module.exports = new windows_terminal(); \ No newline at end of file