@overdeck/desktop 0.45.11 → 0.45.12

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/deps/winpty/misc/ConinMode.cc

@@ -0,0 +1,117 @@
+#include <windows.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <string>
+#include <vector>
+
+static HANDLE getConin() {
+    HANDLE conin = GetStdHandle(STD_INPUT_HANDLE);
+    if (conin == INVALID_HANDLE_VALUE) {
+        fprintf(stderr, "error: cannot get stdin\n");
+        exit(1);
+    }
+    return conin;
+}
+
+static DWORD getConsoleMode() {
+    DWORD mode = 0;
+    if (!GetConsoleMode(getConin(), &mode)) {
+        fprintf(stderr, "error: GetConsoleMode failed (is stdin a console?)\n");
+        exit(1);
+    }
+    return mode;
+}
+
+static void setConsoleMode(DWORD mode) {
+    if (!SetConsoleMode(getConin(), mode)) {
+        fprintf(stderr, "error: SetConsoleMode failed (is stdin a console?)\n");
+        exit(1);
+    }
+}
+
+static long parseInt(const std::string &s) {
+    errno = 0;
+    char *endptr = nullptr;
+    long result = strtol(s.c_str(), &endptr, 0);
+    if (errno != 0 || !endptr || *endptr != '\0') {
+        fprintf(stderr, "error: could not parse integral argument '%s'\n", s.c_str());
+        exit(1);
+    }
+    return result;
+}
+
+static void usage() {
+    printf("Usage: ConinMode [verb] [options]\n");
+    printf("Verbs:\n");
+    printf("    [info]      Dumps info about mode flags.\n");
+    printf("    get         Prints the mode DWORD.\n");
+    printf("    set VALUE   Sets the mode to VALUE, which can be decimal, hex, or octal.\n");
+    printf("    set VALUE MASK\n");
+    printf("                Same as `set VALUE`, but only alters the bits in MASK.\n");
+    exit(1);
+}
+
+struct {
+    const char *name;
+    DWORD value;
+} kInputFlags[] = {
+    "ENABLE_PROCESSED_INPUT",           ENABLE_PROCESSED_INPUT,         // 0x0001
+    "ENABLE_LINE_INPUT",                ENABLE_LINE_INPUT,              // 0x0002
+    "ENABLE_ECHO_INPUT",                ENABLE_ECHO_INPUT,              // 0x0004
+    "ENABLE_WINDOW_INPUT",              ENABLE_WINDOW_INPUT,            // 0x0008
+    "ENABLE_MOUSE_INPUT",               ENABLE_MOUSE_INPUT,             // 0x0010
+    "ENABLE_INSERT_MODE",               ENABLE_INSERT_MODE,             // 0x0020
+    "ENABLE_QUICK_EDIT_MODE",           ENABLE_QUICK_EDIT_MODE,         // 0x0040
+    "ENABLE_EXTENDED_FLAGS",            ENABLE_EXTENDED_FLAGS,          // 0x0080
+    "ENABLE_VIRTUAL_TERMINAL_INPUT", 0x0200/*ENABLE_VIRTUAL_TERMINAL_INPUT*/, // 0x0200
+};
+
+int main(int argc, char *argv[]) {
+    std::vector<std::string> args;
+    for (size_t i = 1; i < argc; ++i) {
+        args.push_back(argv[i]);
+    }
+
+    if (args.empty() || args.size() == 1 && args[0] == "info") {
+        DWORD mode = getConsoleMode();
+        printf("mode: 0x%lx\n", mode);
+        for (const auto &flag : kInputFlags) {
+            printf("%-29s 0x%04lx %s\n", flag.name, flag.value, flag.value & mode ? "ON" : "off");
+            mode &= ~flag.value;
+        }
+        for (int i = 0; i < 32; ++i) {
+            if (mode & (1u << i)) {
+                printf("Unrecognized flag: %04x\n", (1u << i));
+            }
+        }
+        return 0;
+    }
+
+    const auto verb = args[0];
+
+    if (verb == "set") {
+        if (args.size() == 2) {
+            const DWORD newMode = parseInt(args[1]);
+            setConsoleMode(newMode);
+        } else if (args.size() == 3) {
+            const DWORD mode = parseInt(args[1]);
+            const DWORD mask = parseInt(args[2]);
+            const int newMode = (getConsoleMode() & ~mask) | (mode & mask);
+            setConsoleMode(newMode);
+        } else {
+            usage();
+        }
+    } else if (verb == "get") {
+        if (args.size() != 1) {
+            usage();
+        }
+        printf("0x%lx\n", getConsoleMode());
+    } else {
+        usage();
+    }
+
+    return 0;
+}

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/deps/winpty/misc/ConinMode.ps1

@@ -0,0 +1,116 @@
+#
+# PowerShell script for controlling the console QuickEdit and InsertMode flags.
+#
+# Turn QuickEdit off to interact with mouse-driven console programs.
+#
+# Usage:
+#
+# powershell .\ConinMode.ps1 [Options]
+#
+# Options:
+#   -QuickEdit [on/off]
+#   -InsertMode [on/off]
+#   -Mode [integer]
+#
+
+param (
+    [ValidateSet("on", "off")][string] $QuickEdit,
+    [ValidateSet("on", "off")][string] $InsertMode,
+    [int] $Mode
+)
+
+$signature = @'
+[DllImport("kernel32.dll", SetLastError = true)]
+public static extern IntPtr GetStdHandle(int nStdHandle);
+
+[DllImport("kernel32.dll", SetLastError = true)]
+public static extern uint GetConsoleMode(
+    IntPtr hConsoleHandle,
+    out uint lpMode);
+
+[DllImport("kernel32.dll", SetLastError = true)]
+public static extern uint SetConsoleMode(
+    IntPtr hConsoleHandle,
+    uint dwMode);
+
+public const int STD_INPUT_HANDLE = -10;
+public const int ENABLE_INSERT_MODE = 0x0020;
+public const int ENABLE_QUICK_EDIT_MODE = 0x0040;
+public const int ENABLE_EXTENDED_FLAGS = 0x0080;
+'@
+
+$WinAPI = Add-Type -MemberDefinition $signature `
+    -Name WinAPI -Namespace ConinModeScript `
+    -PassThru
+
+function GetConIn {
+    $ret = $WinAPI::GetStdHandle($WinAPI::STD_INPUT_HANDLE)
+    if ($ret -eq -1) {
+        throw "error: cannot get stdin"
+    }
+    return $ret
+}
+
+function GetConsoleMode {
+    $conin = GetConIn
+    $mode = 0
+    $ret = $WinAPI::GetConsoleMode($conin, [ref]$mode)
+    if ($ret -eq 0) {
+        throw "GetConsoleMode failed (is stdin a console?)"
+    }
+    return $mode
+}
+
+function SetConsoleMode($mode) {
+    $conin = GetConIn
+    $ret = $WinAPI::SetConsoleMode($conin, $mode)
+    if ($ret -eq 0) {
+        throw "SetConsoleMode failed (is stdin a console?)"
+    }
+}
+
+$oldMode = GetConsoleMode
+$newMode = $oldMode
+$doingSomething = $false
+
+if ($PSBoundParameters.ContainsKey("Mode")) {
+    $newMode = $Mode
+    $doingSomething = $true
+}
+
+if ($QuickEdit + $InsertMode -ne "") {
+    if (!($newMode -band $WinAPI::ENABLE_EXTENDED_FLAGS)) {
+        # We can't enable an extended flag without overwriting the existing
+        # QuickEdit/InsertMode flags.  AFAICT, there is no way to query their
+        # existing values, so at least we can choose sensible defaults.
+        $newMode = $newMode -bor $WinAPI::ENABLE_EXTENDED_FLAGS
+        $newMode = $newMode -bor $WinAPI::ENABLE_QUICK_EDIT_MODE
+        $newMode = $newMode -bor $WinAPI::ENABLE_INSERT_MODE
+        $doingSomething = $true
+    }
+}
+
+if ($QuickEdit -eq "on") {
+    $newMode = $newMode -bor $WinAPI::ENABLE_QUICK_EDIT_MODE
+    $doingSomething = $true
+} elseif ($QuickEdit -eq "off") {
+    $newMode = $newMode -band (-bnot $WinAPI::ENABLE_QUICK_EDIT_MODE)
+    $doingSomething = $true
+}
+
+if ($InsertMode -eq "on") {
+    $newMode = $newMode -bor $WinAPI::ENABLE_INSERT_MODE
+    $doingSomething = $true
+} elseif ($InsertMode -eq "off") {
+    $newMode = $newMode -band (-bnot $WinAPI::ENABLE_INSERT_MODE)
+    $doingSomething = $true
+}
+
+if ($doingSomething) {
+    echo "old mode: $oldMode"
+    SetConsoleMode $newMode
+    $newMode = GetConsoleMode
+    echo "new mode: $newMode"
+} else {
+    echo "mode: $oldMode"
+}

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/deps/winpty/misc/ConoutMode.cc

@@ -0,0 +1,113 @@
+#include <windows.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <string>
+#include <vector>
+
+static HANDLE getConout() {
+    HANDLE conout = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (conout == INVALID_HANDLE_VALUE) {
+        fprintf(stderr, "error: cannot get stdout\n");
+        exit(1);
+    }
+    return conout;
+}
+
+static DWORD getConsoleMode() {
+    DWORD mode = 0;
+    if (!GetConsoleMode(getConout(), &mode)) {
+        fprintf(stderr, "error: GetConsoleMode failed (is stdout a console?)\n");
+        exit(1);
+    }
+    return mode;
+}
+
+static void setConsoleMode(DWORD mode) {
+    if (!SetConsoleMode(getConout(), mode)) {
+        fprintf(stderr, "error: SetConsoleMode failed (is stdout a console?)\n");
+        exit(1);
+    }
+}
+
+static long parseInt(const std::string &s) {
+    errno = 0;
+    char *endptr = nullptr;
+    long result = strtol(s.c_str(), &endptr, 0);
+    if (errno != 0 || !endptr || *endptr != '\0') {
+        fprintf(stderr, "error: could not parse integral argument '%s'\n", s.c_str());
+        exit(1);
+    }
+    return result;
+}
+
+static void usage() {
+    printf("Usage: ConoutMode [verb] [options]\n");
+    printf("Verbs:\n");
+    printf("    [info]      Dumps info about mode flags.\n");
+    printf("    get         Prints the mode DWORD.\n");
+    printf("    set VALUE   Sets the mode to VALUE, which can be decimal, hex, or octal.\n");
+    printf("    set VALUE MASK\n");
+    printf("                Same as `set VALUE`, but only alters the bits in MASK.\n");
+    exit(1);
+}
+
+struct {
+    const char *name;
+    DWORD value;
+} kOutputFlags[] = {
+    "ENABLE_PROCESSED_OUTPUT",          ENABLE_PROCESSED_OUTPUT,        // 0x0001
+    "ENABLE_WRAP_AT_EOL_OUTPUT",        ENABLE_WRAP_AT_EOL_OUTPUT,      // 0x0002
+    "ENABLE_VIRTUAL_TERMINAL_PROCESSING", 0x0004/*ENABLE_VIRTUAL_TERMINAL_PROCESSING*/, // 0x0004
+    "DISABLE_NEWLINE_AUTO_RETURN",      0x0008/*DISABLE_NEWLINE_AUTO_RETURN*/, // 0x0008
+    "ENABLE_LVB_GRID_WORLDWIDE",        0x0010/*ENABLE_LVB_GRID_WORLDWIDE*/, //0x0010
+};
+
+int main(int argc, char *argv[]) {
+    std::vector<std::string> args;
+    for (size_t i = 1; i < argc; ++i) {
+        args.push_back(argv[i]);
+    }
+
+    if (args.empty() || args.size() == 1 && args[0] == "info") {
+        DWORD mode = getConsoleMode();
+        printf("mode: 0x%lx\n", mode);
+        for (const auto &flag : kOutputFlags) {
+            printf("%-34s 0x%04lx %s\n", flag.name, flag.value, flag.value & mode ? "ON" : "off");
+            mode &= ~flag.value;
+        }
+        for (int i = 0; i < 32; ++i) {
+            if (mode & (1u << i)) {
+                printf("Unrecognized flag: %04x\n", (1u << i));
+            }
+        }
+        return 0;
+    }
+
+    const auto verb = args[0];
+
+    if (verb == "set") {
+        if (args.size() == 2) {
+            const DWORD newMode = parseInt(args[1]);
+            setConsoleMode(newMode);
+        } else if (args.size() == 3) {
+            const DWORD mode = parseInt(args[1]);
+            const DWORD mask = parseInt(args[2]);
+            const int newMode = (getConsoleMode() & ~mask) | (mode & mask);
+            setConsoleMode(newMode);
+        } else {
+            usage();
+        }
+    } else if (verb == "get") {
+        if (args.size() != 1) {
+            usage();
+        }
+        printf("0x%lx\n", getConsoleMode());
+    } else {
+        usage();
+    }
+
+    return 0;
+}

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/deps/winpty/misc/DebugClient.py

@@ -0,0 +1,42 @@
+#!python
+# Run with native CPython.  Needs pywin32 extensions.
+
+# Copyright (c) 2011-2012 Ryan Prichard
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import winerror
+import win32pipe
+import win32file
+import win32api
+import sys
+import pywintypes
+import time
+
+if len(sys.argv) != 2:
+    print("Usage: %s message" % sys.argv[0])
+    sys.exit(1)
+
+message = "[%05.3f %s]: %s" % (time.time() % 100000, sys.argv[0], sys.argv[1])
+
+win32pipe.CallNamedPipe(
+    "\\\\.\\pipe\\DebugServer",
+    message.encode(),
+    16,
+    win32pipe.NMPWAIT_WAIT_FOREVER)

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/deps/winpty/misc/DebugServer.py

@@ -0,0 +1,63 @@
+#!python
+#
+# Run with native CPython.  Needs pywin32 extensions.
+
+# Copyright (c) 2011-2012 Ryan Prichard
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import win32pipe
+import win32api
+import win32file
+import time
+import threading
+import sys
+
+# A message may not be larger than this size.
+MSG_SIZE=4096
+
+serverPipe = win32pipe.CreateNamedPipe(
+    "\\\\.\\pipe\\DebugServer",
+    win32pipe.PIPE_ACCESS_DUPLEX,
+    win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE,
+    win32pipe.PIPE_UNLIMITED_INSTANCES,
+    MSG_SIZE,
+    MSG_SIZE,
+    10 * 1000,
+    None)
+while True:
+    win32pipe.ConnectNamedPipe(serverPipe, None)
+    (ret, data) = win32file.ReadFile(serverPipe, MSG_SIZE)
+    print(data.decode())
+    sys.stdout.flush()
+
+    # The client uses CallNamedPipe to send its message.  CallNamedPipe waits
+    # for a reply message.  If I send a reply, however, using WriteFile, then
+    # sometimes WriteFile fails with:
+    #     pywintypes.error: (232, 'WriteFile', 'The pipe is being closed.')
+    # I can't figure out how to write a strictly correct pipe server, but if
+    # I comment out the WriteFile line, then everything seems to work.  I
+    # think the DisconnectNamedPipe call aborts the client's CallNamedPipe
+    # call normally.
+
+    try:
+        win32file.WriteFile(serverPipe, b'OK')
+    except:
+        pass
+    win32pipe.DisconnectNamedPipe(serverPipe)

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/deps/winpty/misc/DumpLines.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+import sys
+
+for i in range(1, int(sys.argv[1]) + 1):
+    print i, "X" * 78

package/server/supervisor/vendor/@homebridge/node-pty-prebuilt-multiarch/deps/winpty/misc/EnableExtendedFlags.txt

@@ -0,0 +1,46 @@
+Note regarding ENABLE_EXTENDED_FLAGS (2016-05-30)
+
+There is a complicated interaction between the ENABLE_EXTENDED_FLAGS flag
+and the ENABLE_QUICK_EDIT_MODE and ENABLE_INSERT_MODE flags (presumably for
+backwards compatibility?).  I studied the behavior on Windows 7 and Windows
+10, with both the old and new consoles, and I didn't see any differences
+between versions.  Here's what I seemed to observe:
+
+ - The console has three flags internally:
+    - QuickEdit
+    - InsertMode
+    - ExtendedFlags
+
+ - SetConsoleMode psuedocode:
+      void SetConsoleMode(..., DWORD mode) {
+        ExtendedFlags = (mode & (ENABLE_EXTENDED_FLAGS
+                                  | ENABLE_QUICK_EDIT_MODE
+                                  | ENABLE_INSERT_MODE    )) != 0;
+        if (ExtendedFlags) {
+          QuickEdit = (mode & ENABLE_QUICK_EDIT_MODE) != 0;
+          InsertMode = (mode & ENABLE_INSERT_MODE) != 0;
+        }
+      }
+
+ - Setting QuickEdit or InsertMode from the properties dialog GUI does not
+   affect the ExtendedFlags setting -- it simply toggles the one flag.
+
+ - GetConsoleMode psuedocode:
+      GetConsoleMode(..., DWORD *result) {
+        if (ExtendedFlags) {
+          *result |= ENABLE_EXTENDED_FLAGS;
+          if (QuickEdit) { *result |= ENABLE_QUICK_EDIT_MODE; }
+          if (InsertMode) { *result |= ENABLE_INSERT_MODE; }
+        }
+      }
+
+Effectively, the ExtendedFlags flags controls whether the other two flags
+are visible/controlled by the user application.  If they aren't visible,
+though, there is no way for the user application to make them visible,
+except by overwriting their values!  Calling SetConsoleMode with just
+ENABLE_EXTENDED_FLAGS would clear the extended flags we want to read.
+
+Consequently, if a program temporarily alters the QuickEdit flag (e.g. to
+enable mouse input), it cannot restore the original values of the QuickEdit
+and InsertMode flags, UNLESS every other console program cooperates by
+keeping the ExtendedFlags flag set.