@shitiandmw/node-pty 1.1.0-agent.0

package/deps/winpty/src/shared/AgentMsg.h

@@ -0,0 +1,38 @@
+// 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.
+
+#ifndef WINPTY_SHARED_AGENT_MSG_H
+#define WINPTY_SHARED_AGENT_MSG_H
+
+struct AgentMsg
+{
+    enum Type {
+        StartProcess,
+        SetSize,
+        GetConsoleProcessList,
+    };
+};
+
+enum class StartProcessResult {
+    CreateProcessFailed,
+    ProcessCreated,
+};
+
+#endif // WINPTY_SHARED_AGENT_MSG_H

package/deps/winpty/src/shared/BackgroundDesktop.cc

@@ -0,0 +1,122 @@
+// Copyright (c) 2011-2016 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.
+
+#include "BackgroundDesktop.h"
+
+#include <memory>
+
+#include "DebugClient.h"
+#include "StringUtil.h"
+#include "WinptyException.h"
+
+namespace {
+
+static std::wstring getObjectName(HANDLE object) {
+    BOOL success;
+    DWORD lengthNeeded = 0;
+    GetUserObjectInformationW(object, UOI_NAME,
+                              nullptr, 0,
+                              &lengthNeeded);
+    ASSERT(lengthNeeded % sizeof(wchar_t) == 0);
+    std::unique_ptr<wchar_t[]> tmp(
+        new wchar_t[lengthNeeded / sizeof(wchar_t)]);
+    success = GetUserObjectInformationW(object, UOI_NAME,
+                                        tmp.get(), lengthNeeded,
+                                        nullptr);
+    if (!success) {
+        throwWindowsError(L"GetUserObjectInformationW failed");
+    }
+    return std::wstring(tmp.get());
+}
+
+static std::wstring getDesktopName(HWINSTA winsta, HDESK desk) {
+    return getObjectName(winsta) + L"\\" + getObjectName(desk);
+}
+
+} // anonymous namespace
+
+// Get a non-interactive window station for the agent.
+// TODO: review security w.r.t. windowstation and desktop.
+BackgroundDesktop::BackgroundDesktop() {
+    try {
+        m_originalStation = GetProcessWindowStation();
+        if (m_originalStation == nullptr) {
+            throwWindowsError(
+                L"BackgroundDesktop ctor: "
+                L"GetProcessWindowStation returned NULL");
+        }
+        m_newStation =
+            CreateWindowStationW(nullptr, 0, WINSTA_ALL_ACCESS, nullptr);
+        if (m_newStation == nullptr) {
+            throwWindowsError(
+                L"BackgroundDesktop ctor: CreateWindowStationW returned NULL");
+        }
+        if (!SetProcessWindowStation(m_newStation)) {
+            throwWindowsError(
+                L"BackgroundDesktop ctor: SetProcessWindowStation failed");
+        }
+        m_newDesktop = CreateDesktopW(
+            L"Default", nullptr, nullptr, 0, GENERIC_ALL, nullptr);
+        if (m_newDesktop == nullptr) {
+            throwWindowsError(
+                L"BackgroundDesktop ctor: CreateDesktopW failed");
+        }
+        m_newDesktopName = getDesktopName(m_newStation, m_newDesktop);
+        TRACE("Created background desktop: %s",
+            utf8FromWide(m_newDesktopName).c_str());
+    } catch (...) {
+        dispose();
+        throw;
+    }
+}
+
+void BackgroundDesktop::dispose() WINPTY_NOEXCEPT {
+    if (m_originalStation != nullptr) {
+        SetProcessWindowStation(m_originalStation);
+        m_originalStation = nullptr;
+    }
+    if (m_newDesktop != nullptr) {
+        CloseDesktop(m_newDesktop);
+        m_newDesktop = nullptr;
+    }
+    if (m_newStation != nullptr) {
+        CloseWindowStation(m_newStation);
+        m_newStation = nullptr;
+    }
+}
+
+std::wstring getCurrentDesktopName() {
+    // MSDN says that the handles returned by GetProcessWindowStation and
+    // GetThreadDesktop do not need to be passed to CloseWindowStation and
+    // CloseDesktop, respectively.
+    const HWINSTA winsta = GetProcessWindowStation();
+    if (winsta == nullptr) {
+        throwWindowsError(
+            L"getCurrentDesktopName: "
+            L"GetProcessWindowStation returned NULL");
+    }
+    const HDESK desk = GetThreadDesktop(GetCurrentThreadId());
+    if (desk == nullptr) {
+        throwWindowsError(
+            L"getCurrentDesktopName: "
+            L"GetThreadDesktop returned NULL");
+    }
+    return getDesktopName(winsta, desk);
+}

package/deps/winpty/src/shared/BackgroundDesktop.h

@@ -0,0 +1,73 @@
+// Copyright (c) 2011-2016 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.
+
+#ifndef WINPTY_SHARED_BACKGROUND_DESKTOP_H
+#define WINPTY_SHARED_BACKGROUND_DESKTOP_H
+
+#include <windows.h>
+
+#include <string>
+
+#include "WinptyException.h"
+
+class BackgroundDesktop {
+public:
+    BackgroundDesktop();
+    ~BackgroundDesktop() { dispose(); }
+    void dispose() WINPTY_NOEXCEPT;
+    const std::wstring &desktopName() const { return m_newDesktopName; }
+
+    BackgroundDesktop(const BackgroundDesktop &other) = delete;
+    BackgroundDesktop &operator=(const BackgroundDesktop &other) = delete;
+
+    // We can't default the move constructor and assignment operator with
+    // MSVC 2013.  We *could* if we required at least MSVC 2015 to build.
+
+    BackgroundDesktop(BackgroundDesktop &&other) :
+            m_originalStation(other.m_originalStation),
+            m_newStation(other.m_newStation),
+            m_newDesktop(other.m_newDesktop),
+            m_newDesktopName(std::move(other.m_newDesktopName)) {
+        other.m_originalStation = nullptr;
+        other.m_newStation = nullptr;
+        other.m_newDesktop = nullptr;
+    }
+    BackgroundDesktop &operator=(BackgroundDesktop &&other) {
+        dispose();
+        m_originalStation = other.m_originalStation;
+        m_newStation = other.m_newStation;
+        m_newDesktop = other.m_newDesktop;
+        m_newDesktopName = std::move(other.m_newDesktopName);
+        other.m_originalStation = nullptr;
+        other.m_newStation = nullptr;
+        other.m_newDesktop = nullptr;
+        return *this;
+    }
+
+private:
+    HWINSTA m_originalStation = nullptr;
+    HWINSTA m_newStation = nullptr;
+    HDESK m_newDesktop = nullptr;
+    std::wstring m_newDesktopName;
+};
+
+std::wstring getCurrentDesktopName();
+
+#endif // WINPTY_SHARED_BACKGROUND_DESKTOP_H

package/deps/winpty/src/shared/Buffer.cc

@@ -0,0 +1,103 @@
+// Copyright (c) 2011-2016 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.
+
+#include "Buffer.h"
+
+#include <stdint.h>
+
+#include "DebugClient.h"
+#include "WinptyAssert.h"
+
+// Define the READ_BUFFER_CHECK() macro.  It *must* evaluate its condition,
+// exactly once.
+#define READ_BUFFER_CHECK(cond)                                 \
+    do {                                                        \
+        if (!(cond)) {                                          \
+            trace("decode error: %s", #cond);                   \
+            throw DecodeError();                                \
+        }                                                       \
+    } while (false)
+
+enum class Piece : uint8_t { Int32, Int64, WString };
+
+void WriteBuffer::putRawData(const void *data, size_t len) {
+    const auto p = reinterpret_cast<const char*>(data);
+    m_buf.insert(m_buf.end(), p, p + len);
+}
+
+void WriteBuffer::replaceRawData(size_t pos, const void *data, size_t len) {
+    ASSERT(pos <= m_buf.size() && len <= m_buf.size() - pos);
+    const auto p = reinterpret_cast<const char*>(data);
+    std::copy(p, p + len, &m_buf[pos]);
+}
+
+void WriteBuffer::putInt32(int32_t i) {
+    putRawValue(Piece::Int32);
+    putRawValue(i);
+}
+
+void WriteBuffer::putInt64(int64_t i) {
+    putRawValue(Piece::Int64);
+    putRawValue(i);
+}
+
+// len is in characters, excluding NUL, i.e. the number of wchar_t elements
+void WriteBuffer::putWString(const wchar_t *str, size_t len) {
+    putRawValue(Piece::WString);
+    putRawValue(static_cast<uint64_t>(len));
+    putRawData(str, sizeof(wchar_t) * len);
+}
+
+void ReadBuffer::getRawData(void *data, size_t len) {
+    ASSERT(m_off <= m_buf.size());
+    READ_BUFFER_CHECK(len <= m_buf.size() - m_off);
+    const char *const inp = &m_buf[m_off];
+    std::copy(inp, inp + len, reinterpret_cast<char*>(data));
+    m_off += len;
+}
+
+int32_t ReadBuffer::getInt32() {
+    READ_BUFFER_CHECK(getRawValue<Piece>() == Piece::Int32);
+    return getRawValue<int32_t>();
+}
+
+int64_t ReadBuffer::getInt64() {
+    READ_BUFFER_CHECK(getRawValue<Piece>() == Piece::Int64);
+    return getRawValue<int64_t>();
+}
+
+std::wstring ReadBuffer::getWString() {
+    READ_BUFFER_CHECK(getRawValue<Piece>() == Piece::WString);
+    const uint64_t charLen = getRawValue<uint64_t>();
+    READ_BUFFER_CHECK(charLen <= SIZE_MAX / sizeof(wchar_t));
+    // To be strictly conforming, we can't use the convenient wstring
+    // constructor, because the string in m_buf mightn't be aligned.
+    std::wstring ret;
+    if (charLen > 0) {
+        const size_t byteLen = charLen * sizeof(wchar_t);
+        ret.resize(charLen);
+        getRawData(&ret[0], byteLen);
+    }
+    return ret;
+}
+
+void ReadBuffer::assertEof() {
+    READ_BUFFER_CHECK(m_off == m_buf.size());
+}

package/deps/winpty/src/shared/Buffer.h

@@ -0,0 +1,102 @@
+// Copyright (c) 2011-2016 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.
+
+#ifndef WINPTY_SHARED_BUFFER_H
+#define WINPTY_SHARED_BUFFER_H
+
+#include <stdint.h>
+#include <string.h>
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+#include <string>
+
+#include "WinptyException.h"
+
+class WriteBuffer {
+private:
+    std::vector<char> m_buf;
+
+public:
+    WriteBuffer() {}
+
+    template <typename T> void putRawValue(const T &t) {
+        putRawData(&t, sizeof(t));
+    }
+    template <typename T> void replaceRawValue(size_t pos, const T &t) {
+        replaceRawData(pos, &t, sizeof(t));
+    }
+
+    void putRawData(const void *data, size_t len);
+    void replaceRawData(size_t pos, const void *data, size_t len);
+    void putInt32(int32_t i);
+    void putInt64(int64_t i);
+    void putWString(const wchar_t *str, size_t len);
+    void putWString(const wchar_t *str)         { putWString(str, wcslen(str)); }
+    void putWString(const std::wstring &str)    { putWString(str.data(), str.size()); }
+    std::vector<char> &buf()                    { return m_buf; }
+
+    // MSVC 2013 does not generate these automatically, so help it out.
+    WriteBuffer(WriteBuffer &&other) : m_buf(std::move(other.m_buf)) {}
+    WriteBuffer &operator=(WriteBuffer &&other) {
+        m_buf = std::move(other.m_buf);
+        return *this;
+    }
+};
+
+class ReadBuffer {
+public:
+    class DecodeError : public WinptyException {
+        virtual const wchar_t *what() const WINPTY_NOEXCEPT override {
+            return L"DecodeError: RPC message decoding error";
+        }
+    };
+
+private:
+    std::vector<char> m_buf;
+    size_t m_off = 0;
+
+public:
+    explicit ReadBuffer(std::vector<char> &&buf) : m_buf(std::move(buf)) {}
+
+    template <typename T> T getRawValue() {
+        T ret = {};
+        getRawData(&ret, sizeof(ret));
+        return ret;
+    }
+
+    void getRawData(void *data, size_t len);
+    int32_t getInt32();
+    int64_t getInt64();
+    std::wstring getWString();
+    void assertEof();
+
+    // MSVC 2013 does not generate these automatically, so help it out.
+    ReadBuffer(ReadBuffer &&other) :
+        m_buf(std::move(other.m_buf)), m_off(other.m_off) {}
+    ReadBuffer &operator=(ReadBuffer &&other) {
+        m_buf = std::move(other.m_buf);
+        m_off = other.m_off;
+        return *this;
+    }
+};
+
+#endif // WINPTY_SHARED_BUFFER_H

package/deps/winpty/src/shared/DebugClient.cc

@@ -0,0 +1,187 @@
+// 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.
+
+#include "DebugClient.h"
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <algorithm>
+#include <string>
+
+#include "winpty_snprintf.h"
+
+const wchar_t *const kPipeName = L"\\\\.\\pipe\\DebugServer";
+
+void *volatile g_debugConfig;
+
+namespace {
+
+// It would be easy to accidentally trample on the Windows LastError value
+// by adding logging/debugging code.  Ensure that can't happen by saving and
+// restoring the value.  This saving and restoring doesn't happen along the
+// fast path.
+class PreserveLastError {
+public:
+    PreserveLastError() : m_lastError(GetLastError()) {}
+    ~PreserveLastError() { SetLastError(m_lastError); }
+private:
+    DWORD m_lastError;
+};
+
+} // anonymous namespace
+
+static void sendToDebugServer(const char *message)
+{
+    HANDLE tracePipe = INVALID_HANDLE_VALUE;
+
+    do {
+        // The default impersonation level is SECURITY_IMPERSONATION, which allows
+        // a sufficiently authorized named pipe server to impersonate the client.
+        // There's no need for impersonation in this debugging system, so reduce
+        // the impersonation level to SECURITY_IDENTIFICATION, which allows a
+        // server to merely identify us.
+        tracePipe = CreateFileW(
+            kPipeName,
+            GENERIC_READ | GENERIC_WRITE,
+            0, NULL, OPEN_EXISTING,
+            SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION,
+            NULL);
+    } while (tracePipe == INVALID_HANDLE_VALUE &&
+             GetLastError() == ERROR_PIPE_BUSY &&
+             WaitNamedPipeW(kPipeName, NMPWAIT_WAIT_FOREVER));
+
+    if (tracePipe != INVALID_HANDLE_VALUE) {
+        DWORD newMode = PIPE_READMODE_MESSAGE;
+        SetNamedPipeHandleState(tracePipe, &newMode, NULL, NULL);
+        char response[16];
+        DWORD actual = 0;
+        TransactNamedPipe(tracePipe,
+            const_cast<char*>(message), strlen(message),
+            response, sizeof(response), &actual, NULL);
+        CloseHandle(tracePipe);
+    }
+}
+
+// Get the current UTC time as milliseconds from the epoch (ignoring leap
+// seconds).  Use the Unix epoch for consistency with DebugClient.py.  There
+// are 134774 days between 1601-01-01 (the Win32 epoch) and 1970-01-01 (the
+// Unix epoch).
+static long long unixTimeMillis()
+{
+    FILETIME fileTime;
+    GetSystemTimeAsFileTime(&fileTime);
+    long long msTime = (((long long)fileTime.dwHighDateTime << 32) +
+                       fileTime.dwLowDateTime) / 10000;
+    return msTime - 134774LL * 24 * 3600 * 1000;
+}
+
+static const char *getDebugConfig()
+{
+    if (g_debugConfig == NULL) {
+        PreserveLastError preserve;
+        const int bufSize = 256;
+        char buf[bufSize];
+        DWORD actualSize =
+            GetEnvironmentVariableA("WINPTY_DEBUG", buf, bufSize);
+        if (actualSize == 0 || actualSize >= static_cast<DWORD>(bufSize)) {
+            buf[0] = '\0';
+        }
+        const size_t len = strlen(buf) + 1;
+        char *newConfig = new char[len];
+        std::copy(buf, buf + len, newConfig);
+        void *oldValue = InterlockedCompareExchangePointer(
+            &g_debugConfig, newConfig, NULL);
+        if (oldValue != NULL) {
+            delete [] newConfig;
+        }
+    }
+    return static_cast<const char*>(g_debugConfig);
+}
+
+bool isTracingEnabled()
+{
+    static bool disabled, enabled;
+    if (disabled) {
+        return false;
+    } else if (enabled) {
+        return true;
+    } else {
+        // Recognize WINPTY_DEBUG=1 for backwards compatibility.
+        PreserveLastError preserve;
+        bool value = hasDebugFlag("trace") || hasDebugFlag("1");
+        disabled = !value;
+        enabled = value;
+        return value;
+    }
+}
+
+bool hasDebugFlag(const char *flag)
+{
+    if (strchr(flag, ',') != NULL) {
+        trace("INTERNAL ERROR: hasDebugFlag flag has comma: '%s'", flag);
+        abort();
+    }
+    const char *const configCStr = getDebugConfig();
+    if (configCStr[0] == '\0') {
+        return false;
+    }
+    PreserveLastError preserve;
+    std::string config(configCStr);
+    std::string flagStr(flag);
+    config = "," + config + ",";
+    flagStr = "," + flagStr + ",";
+    return config.find(flagStr) != std::string::npos;
+}
+
+void trace(const char *format, ...)
+{
+    if (!isTracingEnabled())
+        return;
+
+    PreserveLastError preserve;
+    char message[1024];
+
+    va_list ap;
+    va_start(ap, format);
+    winpty_vsnprintf(message, format, ap);
+    message[sizeof(message) - 1] = '\0';
+    va_end(ap);
+
+    const int currentTime = (int)(unixTimeMillis() % (100000 * 1000));
+
+    char moduleName[1024];
+    moduleName[0] = '\0';
+    GetModuleFileNameA(NULL, moduleName, sizeof(moduleName));
+    const char *baseName = strrchr(moduleName, '\\');
+    baseName = (baseName != NULL) ? baseName + 1 : moduleName;
+
+    char fullMessage[1024];
+    winpty_snprintf(fullMessage,
+             "[%05d.%03d %s,p%04d,t%04d]: %s",
+             currentTime / 1000, currentTime % 1000,
+             baseName, (int)GetCurrentProcessId(), (int)GetCurrentThreadId(),
+             message);
+    fullMessage[sizeof(fullMessage) - 1] = '\0';
+
+    sendToDebugServer(fullMessage);
+}

package/deps/winpty/src/shared/DebugClient.h

@@ -0,0 +1,38 @@
+// 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.
+
+#ifndef DEBUGCLIENT_H
+#define DEBUGCLIENT_H
+
+#include "winpty_snprintf.h"
+
+bool isTracingEnabled();
+bool hasDebugFlag(const char *flag);
+void trace(const char *format, ...) WINPTY_SNPRINTF_FORMAT(1, 2);
+
+// This macro calls trace without evaluating the arguments.
+#define TRACE(format, ...)                          \
+    do {                                            \
+        if (isTracingEnabled()) {                   \
+            trace((format), ## __VA_ARGS__);        \
+        }                                           \
+    } while (false)
+
+#endif // DEBUGCLIENT_H