@shitiandmw/node-pty 1.1.0-agent.0

package/deps/winpty/misc/VeryLargeRead.cc

@@ -0,0 +1,122 @@
+//
+// 2015-09-25
+// I measured these limits on the size of a single ReadConsoleOutputW call.
+// The limit seems to more-or-less disppear with Windows 8, which is the first
+// OS to stop using ALPCs for console I/O.  My guess is that the new I/O
+// method does not use the 64KiB shared memory buffer that the ALPC method
+// uses.
+//
+// I'm guessing the remaining difference between Windows 8/8.1 and Windows 10
+// might be related to the 32-vs-64-bitness.
+//
+// Client OSs
+//
+// Windows XP 32-bit VM ==> up to 13304 characters
+//  - 13304x1 works, but 13305x1 fails instantly
+// Windows 7 32-bit VM ==> between 16-17 thousand characters
+//  - 16000x1 works, 17000x1 fails instantly
+//  - 163x100 *crashes* conhost.exe but leaves VeryLargeRead.exe running
+// Windows 8 32-bit VM ==> between 240-250 million characters
+//  - 10000x24000 works, but 10000x25000 does not
+// Windows 8.1 32-bit VM ==> between 240-250 million characters
+//  - 10000x24000 works, but 10000x25000 does not
+// Windows 10 64-bit VM ==> no limit (tested to 576 million characters)
+//  - 24000x24000 works
+//  - `ver` reports [Version 10.0.10240], conhost.exe and ConhostV1.dll are
+//    10.0.10240.16384 for file and product version.  ConhostV2.dll is
+//    10.0.10240.16391 for file and product version.
+//
+// Server OSs
+//
+// Windows Server 2008 64-bit VM ==> 14300-14400 characters
+//  - 14300x1 works, 14400x1 fails instantly
+//  - This OS does not have conhost.exe.
+//  - `ver` reports [Version 6.0.6002]
+// Windows Server 2008 R2 64-bit VM ==> 15600-15700 characters
+//  - 15600x1 works, 15700x1 fails instantly
+//  - This OS has conhost.exe, and procexp.exe reveals console ALPC ports in
+//    use in conhost.exe.
+//  - `ver` reports [Version 6.1.7601], conhost.exe is 6.1.7601.23153 for file
+//    and product version.
+// Windows Server 2012 64-bit VM ==> at least 100 million characters
+//  - 10000x10000 works (VM had only 1GiB of RAM, so I skipped larger tests)
+//  - This OS has Windows 8's task manager and procexp.exe reveals the same
+//    lack of ALPC ports and the same \Device\ConDrv\* files as Windows 8.
+//  - `ver` reports [Version 6.2.9200], conhost.exe is 6.2.9200.16579 for file
+//    and product version.
+//
+// To summarize:
+//
+// client-OS    server-OS               notes
+// ---------------------------------------------------------------------------
+// XP           Server 2008             CSRSS, small reads
+// 7            Server 2008 R2          ALPC-to-conhost, small reads
+// 8, 8.1       Server 2012             new I/O interface, large reads allowed
+// 10           <no server OS yet>      enhanced console w/rewrapping
+//
+// (Presumably, Win2K, Vista, and Win2K3 behave the same as XP.  conhost.exe
+// was announced as a Win7 feature.)
+//
+
+#include <windows.h>
+#include <assert.h>
+#include <vector>
+
+#include "TestUtil.cc"
+
+int main(int argc, char *argv[]) {
+    long long width = 9000;
+    long long height = 9000;
+
+    assert(argc >= 1);
+    if (argc == 4) {
+        width = atoi(argv[2]);
+        height = atoi(argv[3]);
+    } else {
+        if (argc == 3) {
+            width = atoi(argv[1]);
+            height = atoi(argv[2]);
+        }
+        wchar_t args[1024];
+        swprintf(args, 1024, L"CHILD %lld %lld", width, height);
+        startChildProcess(args);
+        return 0;
+    }
+
+    const HANDLE conout = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(width, height);
+    setWindowPos(0, 0, std::min(80LL, width), std::min(50LL, height));
+
+    setCursorPos(0, 0);
+    printf("A");
+    fflush(stdout);
+    setCursorPos(width - 2, height - 1);
+    printf("B");
+    fflush(stdout);
+
+    trace("sizeof(CHAR_INFO) = %d", (int)sizeof(CHAR_INFO));
+
+    trace("Allocating buffer...");
+    CHAR_INFO *buffer = new CHAR_INFO[width * height];
+    assert(buffer != NULL);
+    memset(&buffer[0], 0, sizeof(CHAR_INFO));
+    memset(&buffer[width * height - 2], 0, sizeof(CHAR_INFO));
+
+    COORD bufSize = { width, height };
+    COORD bufCoord = { 0, 0 };
+    SMALL_RECT readRegion = { 0, 0, width - 1, height - 1 };
+    trace("ReadConsoleOutputW: calling...");
+    BOOL success = ReadConsoleOutputW(conout, buffer, bufSize, bufCoord, &readRegion);
+    trace("ReadConsoleOutputW: success=%d", success);
+
+    assert(buffer[0].Char.UnicodeChar == L'A');
+    assert(buffer[width * height - 2].Char.UnicodeChar == L'B');
+    trace("Top-left and bottom-right characters read successfully!");
+
+    Sleep(30000);
+
+    delete [] buffer;
+    return 0;
+}

package/deps/winpty/misc/VkEscapeTest.cc

@@ -0,0 +1,56 @@
+/*
+ * Sending VK_PAUSE to the console window almost works as a mechanism for
+ * pausing it, but it doesn't because the console could turn off the
+ * ENABLE_LINE_INPUT console mode flag.
+ */
+
+#define _WIN32_WINNT 0x0501
+#include <stdio.h>
+#include <stdlib.h>
+#include <windows.h>
+
+CALLBACK DWORD pausingThread(LPVOID dummy)
+{
+    if (1) {
+        Sleep(1000);
+        HWND hwnd = GetConsoleWindow();
+        SendMessage(hwnd, WM_KEYDOWN, VK_PAUSE, 1);
+        Sleep(1000);
+        SendMessage(hwnd, WM_KEYDOWN, VK_ESCAPE, 1);
+    }
+
+    if (0) {
+        INPUT_RECORD ir;
+        memset(&ir, 0, sizeof(ir));
+        ir.EventType = KEY_EVENT;
+        ir.Event.KeyEvent.bKeyDown = TRUE;
+        ir.Event.KeyEvent.wVirtualKeyCode = VK_PAUSE;
+        ir.Event.KeyEvent.wRepeatCount = 1;
+    }
+
+    return 0;
+}
+
+int main()
+{
+    HANDLE hin = GetStdHandle(STD_INPUT_HANDLE);
+    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
+    COORD c = { 0, 0 };
+
+    DWORD mode;
+    GetConsoleMode(hin, &mode);
+    SetConsoleMode(hin, mode &
+                   ~(ENABLE_LINE_INPUT));
+
+    CreateThread(NULL, 0,
+                 pausingThread, NULL,
+                 0, NULL);
+
+    int i = 0;
+    while (true) {
+        Sleep(100);
+        printf("%d\n", ++i);
+    }
+
+    return 0;
+}

package/deps/winpty/misc/Win10ResizeWhileFrozen.cc

@@ -0,0 +1,52 @@
+/*
+ * Demonstrates a conhost hang that occurs when widening the console buffer
+ * while selection is in progress.  The problem affects the new Windows 10
+ * console, not the "legacy" console mode that Windows 10 also includes.
+ *
+ * First tested with:
+ *  - Windows 10.0.10240
+ *  - conhost.exe version 10.0.10240.16384
+ *  - ConhostV1.dll version 10.0.10240.16384
+ *  - ConhostV2.dll version 10.0.10240.16391
+ */
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wchar.h>
+
+#include "TestUtil.cc"
+
+const int SC_CONSOLE_MARK = 0xFFF2;
+const int SC_CONSOLE_SELECT_ALL = 0xFFF5;
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        startChildProcess(L"CHILD");
+        return 0;
+    }
+
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(80, 25);
+    setWindowPos(0, 0, 80, 25);
+
+    countDown(5);
+
+    SendMessage(GetConsoleWindow(), WM_SYSCOMMAND, SC_CONSOLE_SELECT_ALL, 0);
+    Sleep(2000);
+
+    // This API call does not return.  In the console window, the "Select All"
+    // operation appears to end.  The console window becomes non-responsive,
+    // and the conhost.exe process must be killed from the Task Manager.
+    // (Killing this test program or closing the console window is not
+    // sufficient.)
+    //
+    // The same hang occurs whether line resizing is off or on.  It happens
+    // with both "Mark" and "Select All".  Calling setBufferSize with the
+    // existing buffer size does not hang, but calling it with only a changed
+    // buffer height *does* hang.  Calling setWindowPos does not hang.
+    setBufferSize(120, 25);
+
+    printf("Done...\n");
+    Sleep(2000);
+}

package/deps/winpty/misc/Win10WrapTest1.cc

@@ -0,0 +1,57 @@
+/*
+ * Demonstrates some wrapping behaviors of the new Windows 10 console.
+ */
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "TestUtil.cc"
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        startChildProcess(L"CHILD");
+        return 0;
+    }
+
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(40, 20);
+    setWindowPos(0, 0, 40, 20);
+
+    system("cls");
+
+    repeatChar(39, 'A'); repeatChar(1, ' ');
+    repeatChar(39, 'B'); repeatChar(1, ' ');
+    printf("\n");
+
+    repeatChar(39, 'C'); repeatChar(1, ' ');
+    repeatChar(39, 'D'); repeatChar(1, ' ');
+    printf("\n");
+
+    repeatChar(40, 'E');
+    repeatChar(40, 'F');
+    printf("\n");
+
+    repeatChar(39, 'G'); repeatChar(1, ' ');
+    repeatChar(39, 'H'); repeatChar(1, ' ');
+    printf("\n");
+
+    Sleep(2000);
+
+    setChar(39, 0, '*', 0x24);
+    setChar(39, 1, '*', 0x24);
+
+    setChar(39, 3, ' ', 0x24);
+    setChar(39, 4, ' ', 0x24);
+
+    setChar(38, 6, ' ', 0x24);
+    setChar(38, 7, ' ', 0x24);
+
+    Sleep(2000);
+    setWindowPos(0, 0, 35, 20);
+    setBufferSize(35, 20);
+    trace("DONE");
+
+    printf("Sleeping forever...\n");
+    while(true) { Sleep(1000); }
+}

package/deps/winpty/misc/Win10WrapTest2.cc

@@ -0,0 +1,30 @@
+#include <windows.h>
+
+#include "TestUtil.cc"
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        startChildProcess(L"CHILD");
+        return 0;
+    }
+
+    const int WIDTH = 25;
+
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(WIDTH, 40);
+    setWindowPos(0, 0, WIDTH, 20);
+
+    system("cls");
+
+    for (int i = 0; i < 100; ++i) {
+        printf("FOO(%d)\n", i);
+    }
+
+    repeatChar(5, '\n');
+    repeatChar(WIDTH * 5, '.');
+    repeatChar(10, '\n');
+    setWindowPos(0, 20, WIDTH, 20);
+    writeBox(0, 5, 1, 10, '|');
+
+    Sleep(120000);
+}

package/deps/winpty/misc/Win32Echo1.cc

@@ -0,0 +1,26 @@
+/*
+ * A Win32 program that reads raw console input with ReadFile and echos
+ * it to stdout.
+ */
+
+#include <stdio.h>
+#include <conio.h>
+#include <windows.h>
+
+int main()
+{
+    int count = 0;
+    HANDLE hStdIn = GetStdHandle(STD_INPUT_HANDLE);
+    HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    SetConsoleMode(hStdIn, 0);
+
+    while (true) {
+        DWORD actual;
+        char ch;
+        ReadFile(hStdIn, &ch, 1, &actual, NULL);
+        printf("%02x ", ch);
+        if (++count == 50)
+            break;
+    }
+    return 0;
+}

package/deps/winpty/misc/Win32Echo2.cc

@@ -0,0 +1,19 @@
+/*
+ * A Win32 program that reads raw console input with getch and echos
+ * it to stdout.
+ */
+
+#include <stdio.h>
+#include <conio.h>
+
+int main()
+{
+    int count = 0;
+    while (true) {
+        int ch = getch();
+        printf("%02x ", ch);
+        if (++count == 50)
+            break;
+    }
+    return 0;
+}

package/deps/winpty/misc/Win32Test1.cc

@@ -0,0 +1,46 @@
+#define _WIN32_WINNT 0x0501
+#include "../src/shared/DebugClient.cc"
+#include <windows.h>
+#include <stdio.h>
+
+const int SC_CONSOLE_MARK = 0xFFF2;
+
+CALLBACK DWORD writerThread(void*)
+{
+    while (true) {
+        Sleep(1000);
+        trace("writing");
+        printf("X\n");
+        trace("written");
+    }
+}
+
+int main()
+{
+    CreateThread(NULL, 0, writerThread, NULL, 0, NULL);
+    trace("marking console");
+    HWND hwnd = GetConsoleWindow();
+    PostMessage(hwnd, WM_SYSCOMMAND, SC_CONSOLE_MARK, 0);
+
+    Sleep(2000);
+
+    trace("reading output");
+    CHAR_INFO buf[1];
+    COORD bufSize = { 1, 1 };
+    COORD zeroCoord = { 0, 0 };
+    SMALL_RECT readRect = { 0, 0, 0, 0 };
+    ReadConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE),
+                      buf,
+                      bufSize,
+                      zeroCoord,
+                      &readRect);
+    trace("done reading output");
+
+    Sleep(2000);
+
+    PostMessage(hwnd, WM_CHAR, 27, 0x00010001);
+
+    Sleep(1100);
+
+    return 0;
+}

package/deps/winpty/misc/Win32Test2.cc

@@ -0,0 +1,70 @@
+/*
+ * This test demonstrates that putting a console into selection mode does not
+ * block the low-level console APIs, even though it blocks WriteFile.
+ */
+
+#define _WIN32_WINNT 0x0501
+#include "../src/shared/DebugClient.cc"
+#include <windows.h>
+#include <stdio.h>
+
+const int SC_CONSOLE_MARK = 0xFFF2;
+
+CALLBACK DWORD writerThread(void*)
+{
+    CHAR_INFO xChar, fillChar;
+    memset(&xChar, 0, sizeof(xChar));
+    xChar.Char.AsciiChar = 'X';
+    xChar.Attributes = 7;
+    memset(&fillChar, 0, sizeof(fillChar));
+    fillChar.Char.AsciiChar = ' ';
+    fillChar.Attributes = 7;
+    COORD oneCoord = { 1, 1 };
+    COORD zeroCoord = { 0, 0 };
+
+    while (true) {
+        SMALL_RECT writeRegion = { 5, 5, 5, 5 };
+        WriteConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE),
+                           &xChar, oneCoord,
+                           zeroCoord,
+                           &writeRegion);
+        Sleep(500);
+        SMALL_RECT scrollRect = { 1, 1, 20, 20 };
+        COORD destCoord = { 0, 0 };
+        ScrollConsoleScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE),
+                                  &scrollRect,
+                                  NULL,
+                                  destCoord,
+                                  &fillChar);
+    }
+}
+
+int main()
+{
+    CreateThread(NULL, 0, writerThread, NULL, 0, NULL);
+    trace("marking console");
+    HWND hwnd = GetConsoleWindow();
+    PostMessage(hwnd, WM_SYSCOMMAND, SC_CONSOLE_MARK, 0);
+
+    Sleep(2000);
+
+    trace("reading output");
+    CHAR_INFO buf[1];
+    COORD bufSize = { 1, 1 };
+    COORD zeroCoord = { 0, 0 };
+    SMALL_RECT readRect = { 0, 0, 0, 0 };
+    ReadConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE),
+                      buf,
+                      bufSize,
+                      zeroCoord,
+                      &readRect);
+    trace("done reading output");
+
+    Sleep(2000);
+
+    PostMessage(hwnd, WM_CHAR, 27, 0x00010001);
+
+    Sleep(1100);
+
+    return 0;
+}

package/deps/winpty/misc/Win32Test3.cc

@@ -0,0 +1,78 @@
+/*
+ * Creates a window station and starts a process under it.  The new process
+ * also gets a new console.
+ */
+
+#include <windows.h>
+#include <string.h>
+#include <stdio.h>
+
+int main()
+{
+    BOOL success;
+
+    SECURITY_ATTRIBUTES sa;
+    memset(&sa, 0, sizeof(sa));
+    sa.bInheritHandle = TRUE;
+
+    HWINSTA originalStation = GetProcessWindowStation();
+    printf("originalStation == 0x%x\n", originalStation);
+    HWINSTA station = CreateWindowStation(NULL,
+                                          0,
+                                          WINSTA_ALL_ACCESS,
+                                          &sa);
+    printf("station == 0x%x\n", station);
+    if (!SetProcessWindowStation(station))
+        printf("SetWindowStation failed!\n");
+    HDESK desktop = CreateDesktop("Default", NULL, NULL,
+                                  /*dwFlags=*/0, GENERIC_ALL,
+                                  &sa);
+    printf("desktop = 0x%x\n", desktop);
+
+    char stationName[256];
+    stationName[0] = '\0';
+    success = GetUserObjectInformation(station, UOI_NAME, 
+                                       stationName, sizeof(stationName),
+                                       NULL);
+    printf("stationName = [%s]\n", stationName);
+
+    char startupDesktop[256];
+    sprintf(startupDesktop, "%s\\Default", stationName);
+
+    STARTUPINFO sui;
+    PROCESS_INFORMATION pi;
+    memset(&sui, 0, sizeof(sui));
+    memset(&pi, 0, sizeof(pi));
+    sui.cb = sizeof(STARTUPINFO);
+    sui.lpDesktop = startupDesktop;
+
+    // Start a cmd subprocess, and have it start its own cmd subprocess.
+    // Both subprocesses will connect to the same non-interactive window
+    // station.
+
+    const char program[] = "c:\\windows\\system32\\cmd.exe";
+    char cmdline[256];
+    sprintf(cmdline, "%s /c cmd", program);
+    success = CreateProcess(program,
+                            cmdline,
+                            NULL,
+                            NULL,
+                            /*bInheritHandles=*/FALSE,
+                            /*dwCreationFlags=*/CREATE_NEW_CONSOLE,
+                            NULL, NULL,
+                            &sui,
+                            &pi);
+
+    printf("pid == %d\n", pi.dwProcessId);
+
+    // This sleep is necessary.  We must give the child enough time to
+    // connect to the specified window station.
+    Sleep(5000);
+
+    SetProcessWindowStation(originalStation);
+    CloseWindowStation(station);
+    CloseDesktop(desktop);
+    Sleep(5000);
+
+    return 0;
+}

package/deps/winpty/misc/Win32Write1.cc

@@ -0,0 +1,44 @@
+/* 
+ * A Win32 program that scrolls and writes to the console using the ioctl-like
+ * interface.
+ */
+
+#include <stdio.h>
+#include <windows.h>
+
+int main()
+{
+    HANDLE conout = GetStdHandle(STD_OUTPUT_HANDLE);
+
+    for (int i = 0; i < 80; ++i) {
+
+        CONSOLE_SCREEN_BUFFER_INFO info;
+        GetConsoleScreenBufferInfo(conout, &info);
+
+        SMALL_RECT src = { 0, 1, info.dwSize.X - 1, info.dwSize.Y - 1 };
+        COORD destOrigin = { 0, 0 };
+        CHAR_INFO fillCharInfo = { 0 };
+        fillCharInfo.Char.AsciiChar = ' ';
+        fillCharInfo.Attributes = 7;
+        ScrollConsoleScreenBuffer(conout,
+                                  &src,
+                                  NULL,
+                                  destOrigin,
+                                  &fillCharInfo);
+
+        CHAR_INFO buffer = { 0 };
+        buffer.Char.AsciiChar = 'X';
+        buffer.Attributes = 7;
+        COORD bufferSize = { 1, 1 };
+        COORD bufferCoord = { 0, 0 };
+        SMALL_RECT writeRegion = { 0, 0, 0, 0 };
+        writeRegion.Left = writeRegion.Right = i;
+        writeRegion.Top = writeRegion.Bottom = 5;
+        WriteConsoleOutput(conout, 
+                           &buffer, bufferSize, bufferCoord,
+                           &writeRegion);
+
+        Sleep(250);
+    }
+    return 0;
+}

package/deps/winpty/misc/WindowsBugCrashReader.cc

@@ -0,0 +1,27 @@
+// I noticed this on the ConEmu web site:
+//
+// https://social.msdn.microsoft.com/Forums/en-US/40c8e395-cca9-45c8-b9b8-2fbe6782ac2b/readconsoleoutput-cause-access-violation-writing-location-exception
+// https://conemu.github.io/en/MicrosoftBugs.html
+//
+// In Windows 7, 8, and 8.1, a ReadConsoleOutputW with an out-of-bounds read
+// region crashes the application.  I have reproduced the problem on Windows 8
+// and 8.1, but not on Windows 7.
+//
+
+#include <windows.h>
+
+#include "TestUtil.cc"
+
+int main() {
+    setWindowPos(0, 0, 1, 1);
+    setBufferSize(80, 25);
+    setWindowPos(0, 0, 80, 25);
+
+    const HANDLE conout = openConout();
+    static CHAR_INFO lineBuf[80];
+    SMALL_RECT readRegion = { 0, 999, 79, 999 };
+    const BOOL ret = ReadConsoleOutputW(conout, lineBuf, {80, 1}, {0, 0}, &readRegion);
+    ASSERT(!ret && "ReadConsoleOutputW should have failed");
+
+    return 0;
+}