@shitiandmw/node-pty 1.1.0-agent.0

package/deps/winpty/src/tests/subdir.mk

@@ -0,0 +1,28 @@
+# Copyright (c) 2015 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.
+
+build/%.exe : src/tests/%.cc build/winpty.dll
+	$(info Building $@)
+	@$(MINGW_CXX) $(MINGW_CXXFLAGS) $(MINGW_LDFLAGS) -o $@ $^
+
+TEST_PROGRAMS = \
+        build/trivial_test.exe
+
+-include $(TEST_PROGRAMS:.exe=.d)

package/deps/winpty/src/tests/trivial_test.cc

@@ -0,0 +1,158 @@
+// Copyright (c) 2015 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 <windows.h>
+
+#include <cassert>
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <cwchar>
+#include <vector>
+
+#include "../include/winpty.h"
+#include "../shared/DebugClient.h"
+
+static std::vector<unsigned char> filterContent(
+        const std::vector<unsigned char> &content) {
+    std::vector<unsigned char> result;
+    auto it = content.begin();
+    const auto itEnd = content.end();
+    while (it < itEnd) {
+        if (*it == '\r') {
+            // Filter out carriage returns.  Sometimes the output starts with
+            // a single CR; other times, it has multiple CRs.
+            it++;
+        } else if (*it == '\x1b' && (it + 1) < itEnd && *(it + 1) == '[') {
+            // Filter out escape sequences.  They have no interior letters and
+            // end with a single letter.
+            it += 2;
+            while (it < itEnd && !isalpha(*it)) {
+                it++;
+            }
+            it++;
+        } else {
+            // Let everything else through.
+            result.push_back(*it);
+            it++;
+        }
+    }
+    return result;
+}
+
+// Read bytes from the non-overlapped file handle until the file is closed or
+// until an I/O error occurs.
+static std::vector<unsigned char> readAll(HANDLE handle) {
+    unsigned char buf[1024];
+    std::vector<unsigned char> result;
+    while (true) {
+        DWORD amount = 0;
+        BOOL ret = ReadFile(handle, buf, sizeof(buf), &amount, nullptr);
+        if (!ret || amount == 0) {
+            break;
+        }
+        result.insert(result.end(), buf, buf + amount);
+    }
+    return result;
+}
+
+static void parentTest() {
+    wchar_t program[1024];
+    wchar_t cmdline[1024];
+    GetModuleFileNameW(nullptr, program, 1024);
+
+    {
+        // XXX: We'd like to use swprintf, which is part of C99 and takes a
+        // size_t maxlen argument.  MinGW-w64 has this function, as does MSVC.
+        // The old MinGW doesn't, though -- instead, it apparently provides an
+        // swprintf taking no maxlen argument.  This *might* be a regression?
+        // (There is also no swnprintf, but that function is obsolescent with a
+        // correct swprintf, and it isn't in POSIX or ISO C.)
+        //
+        // Visual C++ 6 also provided this non-conformant swprintf, and I'm
+        // guessing MSVCRT.DLL does too.  (My impression is that the old MinGW
+        // prefers to rely on MSVCRT.DLL for convenience?)
+        //
+        // I could compile differently for old MinGW, but what if it fixes its
+        // function later?  Instead, use a workaround.  It's starting to make
+        // sense to drop MinGW support in favor of MinGW-w64.  This is too
+        // annoying.
+        //
+        // grepbait: OLD-MINGW / WINPTY_TARGET_MSYS1
+        cmdline[0] = L'\0';
+        wcscat(cmdline, L"\"");
+        wcscat(cmdline, program);
+        wcscat(cmdline, L"\" CHILD");
+    }
+    // swnprintf(cmdline, sizeof(cmdline) / sizeof(cmdline[0]),
+    //           L"\"%ls\" CHILD", program);
+
+    auto agentCfg = winpty_config_new(0, nullptr);
+    assert(agentCfg != nullptr);
+    auto pty = winpty_open(agentCfg, nullptr);
+    assert(pty != nullptr);
+    winpty_config_free(agentCfg);
+
+    HANDLE conin = CreateFileW(
+        winpty_conin_name(pty),
+        GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
+    HANDLE conout = CreateFileW(
+        winpty_conout_name(pty),
+        GENERIC_READ, 0, nullptr, OPEN_EXISTING, 0, nullptr);
+    assert(conin != INVALID_HANDLE_VALUE);
+    assert(conout != INVALID_HANDLE_VALUE);
+
+    auto spawnCfg = winpty_spawn_config_new(
+            WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, program, cmdline,
+            nullptr, nullptr, nullptr);
+    assert(spawnCfg != nullptr);
+    HANDLE process = nullptr;
+    BOOL spawnSuccess = winpty_spawn(
+        pty, spawnCfg, &process, nullptr, nullptr, nullptr);
+    assert(spawnSuccess && process != nullptr);
+
+    auto content = readAll(conout);
+    content = filterContent(content);
+
+    std::vector<unsigned char> expectedContent = {
+        'H', 'I', '\n', 'X', 'Y', '\n'
+    };
+    DWORD exitCode = 0;
+    assert(GetExitCodeProcess(process, &exitCode) && exitCode == 42);
+    CloseHandle(process);
+    CloseHandle(conin);
+    CloseHandle(conout);
+    assert(content == expectedContent);
+    winpty_free(pty);
+}
+
+static void childTest() {
+    printf("HI\nXY\n");
+    exit(42);
+}
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        parentTest();
+    } else {
+        childTest();
+    }
+    return 0;
+}

package/deps/winpty/src/unix-adapter/InputHandler.cc

@@ -0,0 +1,114 @@
+// Copyright (c) 2011-2015 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 "InputHandler.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <sys/select.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "../shared/DebugClient.h"
+#include "Util.h"
+#include "WakeupFd.h"
+
+InputHandler::InputHandler(
+        HANDLE conin, int inputfd, WakeupFd &completionWakeup) :
+    m_conin(conin),
+    m_inputfd(inputfd),
+    m_completionWakeup(completionWakeup),
+    m_threadHasBeenJoined(false),
+    m_shouldShutdown(0),
+    m_threadCompleted(0)
+{
+    pthread_create(&m_thread, NULL, InputHandler::threadProcS, this);
+}
+
+void InputHandler::shutdown() {
+    startShutdown();
+    if (!m_threadHasBeenJoined) {
+        int ret = pthread_join(m_thread, NULL);
+        assert(ret == 0 && "pthread_join failed");
+        m_threadHasBeenJoined = true;
+    }
+}
+
+void InputHandler::threadProc() {
+    std::vector<char> buffer(4096);
+    fd_set readfds;
+    FD_ZERO(&readfds);
+    while (true) {
+        // Handle shutdown.
+        m_wakeup.reset();
+        if (m_shouldShutdown) {
+            trace("InputHandler: shutting down");
+            break;
+        }
+
+        // Block until data arrives.
+        {
+            const int max_fd = std::max(m_inputfd, m_wakeup.fd());
+            FD_SET(m_inputfd, &readfds);
+            FD_SET(m_wakeup.fd(), &readfds);
+            selectWrapper("InputHandler", max_fd + 1, &readfds);
+            if (!FD_ISSET(m_inputfd, &readfds)) {
+                continue;
+            }
+        }
+
+        const int numRead = read(m_inputfd, &buffer[0], buffer.size());
+        if (numRead == -1 && errno == EINTR) {
+            // Apparently, this read is interrupted on Cygwin 1.7 by a SIGWINCH
+            // signal even though I set the SA_RESTART flag on the handler.
+            continue;
+        }
+
+        // tty is closed, or the read failed for some unexpected reason.
+        if (numRead <= 0) {
+            trace("InputHandler: tty read failed: numRead=%d", numRead);
+            break;
+        }
+
+        DWORD written = 0;
+        BOOL ret = WriteFile(m_conin,
+                             &buffer[0], numRead,
+                             &written, NULL);
+        if (!ret || written != static_cast<DWORD>(numRead)) {
+            if (!ret && GetLastError() == ERROR_BROKEN_PIPE) {
+                trace("InputHandler: pipe closed: written=%u",
+                    static_cast<unsigned int>(written));
+            } else {
+                trace("InputHandler: write failed: "
+                    "ret=%d lastError=0x%x numRead=%d written=%u",
+                    ret,
+                    static_cast<unsigned int>(GetLastError()),
+                    numRead,
+                    static_cast<unsigned int>(written));
+            }
+            break;
+        }
+    }
+    m_threadCompleted = 1;
+    m_completionWakeup.set();
+}

package/deps/winpty/src/unix-adapter/InputHandler.h

@@ -0,0 +1,56 @@
+// Copyright (c) 2011-2015 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 UNIX_ADAPTER_INPUT_HANDLER_H
+#define UNIX_ADAPTER_INPUT_HANDLER_H
+
+#include <windows.h>
+#include <pthread.h>
+#include <signal.h>
+
+#include "WakeupFd.h"
+
+// Connect a Cygwin blocking fd to winpty CONIN.
+class InputHandler {
+public:
+    InputHandler(HANDLE conin, int inputfd, WakeupFd &completionWakeup);
+    ~InputHandler() { shutdown(); }
+    bool isComplete() { return m_threadCompleted; }
+    void startShutdown() { m_shouldShutdown = 1; m_wakeup.set(); }
+    void shutdown();
+
+private:
+    static void *threadProcS(void *pvthis) {
+        reinterpret_cast<InputHandler*>(pvthis)->threadProc();
+        return NULL;
+    }
+    void threadProc();
+
+    HANDLE m_conin;
+    int m_inputfd;
+    pthread_t m_thread;
+    WakeupFd &m_completionWakeup;
+    WakeupFd m_wakeup;
+    bool m_threadHasBeenJoined;
+    volatile sig_atomic_t m_shouldShutdown;
+    volatile sig_atomic_t m_threadCompleted;
+};
+
+#endif // UNIX_ADAPTER_INPUT_HANDLER_H

package/deps/winpty/src/unix-adapter/OutputHandler.cc

@@ -0,0 +1,80 @@
+// Copyright (c) 2011-2015 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 "OutputHandler.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <sys/select.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "../shared/DebugClient.h"
+#include "Util.h"
+#include "WakeupFd.h"
+
+OutputHandler::OutputHandler(
+        HANDLE conout, int outputfd, WakeupFd &completionWakeup) :
+    m_conout(conout),
+    m_outputfd(outputfd),
+    m_completionWakeup(completionWakeup),
+    m_threadHasBeenJoined(false),
+    m_threadCompleted(0)
+{
+    pthread_create(&m_thread, NULL, OutputHandler::threadProcS, this);
+}
+
+void OutputHandler::shutdown() {
+    if (!m_threadHasBeenJoined) {
+        int ret = pthread_join(m_thread, NULL);
+        assert(ret == 0 && "pthread_join failed");
+        m_threadHasBeenJoined = true;
+    }
+}
+
+void OutputHandler::threadProc() {
+    std::vector<char> buffer(4096);
+    while (true) {
+        DWORD numRead = 0;
+        BOOL ret = ReadFile(m_conout,
+                            &buffer[0], buffer.size(),
+                            &numRead, NULL);
+        if (!ret || numRead == 0) {
+            if (!ret && GetLastError() == ERROR_BROKEN_PIPE) {
+                trace("OutputHandler: pipe closed: numRead=%u",
+                    static_cast<unsigned int>(numRead));
+            } else {
+                trace("OutputHandler: read failed: "
+                    "ret=%d lastError=0x%x numRead=%u",
+                    ret,
+                    static_cast<unsigned int>(GetLastError()),
+                    static_cast<unsigned int>(numRead));
+            }
+            break;
+        }
+        if (!writeAll(m_outputfd, &buffer[0], numRead)) {
+            break;
+        }
+    }
+    m_threadCompleted = 1;
+    m_completionWakeup.set();
+}

package/deps/winpty/src/unix-adapter/OutputHandler.h

@@ -0,0 +1,53 @@
+// Copyright (c) 2011-2015 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 UNIX_ADAPTER_OUTPUT_HANDLER_H
+#define UNIX_ADAPTER_OUTPUT_HANDLER_H
+
+#include <windows.h>
+#include <pthread.h>
+#include <signal.h>
+
+#include "WakeupFd.h"
+
+// Connect winpty CONOUT/CONERR to a Cygwin blocking fd.
+class OutputHandler {
+public:
+    OutputHandler(HANDLE conout, int outputfd, WakeupFd &completionWakeup);
+    ~OutputHandler() { shutdown(); }
+    bool isComplete() { return m_threadCompleted; }
+    void shutdown();
+
+private:
+    static void *threadProcS(void *pvthis) {
+        reinterpret_cast<OutputHandler*>(pvthis)->threadProc();
+        return NULL;
+    }
+    void threadProc();
+
+    HANDLE m_conout;
+    int m_outputfd;
+    pthread_t m_thread;
+    WakeupFd &m_completionWakeup;
+    bool m_threadHasBeenJoined;
+    volatile sig_atomic_t m_threadCompleted;
+};
+
+#endif // UNIX_ADAPTER_OUTPUT_HANDLER_H

package/deps/winpty/src/unix-adapter/Util.cc

@@ -0,0 +1,86 @@
+// Copyright (c) 2015 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 "Util.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "../shared/DebugClient.h"
+
+// Write the entire buffer, restarting it as necessary.
+bool writeAll(int fd, const void *buffer, size_t size) {
+    size_t written = 0;
+    while (written < size) {
+        int ret = write(fd,
+                        reinterpret_cast<const char*>(buffer) + written,
+                        size - written);
+        if (ret == -1 && errno == EINTR) {
+            continue;
+        }
+        if (ret <= 0) {
+            trace("write failed: "
+                "fd=%d errno=%d size=%u written=%d ret=%d",
+                fd,
+                errno,
+                static_cast<unsigned int>(size),
+                static_cast<unsigned int>(written),
+                ret);
+            return false;
+        }
+        assert(static_cast<size_t>(ret) <= size - written);
+        written += ret;
+    }
+    assert(written == size);
+    return true;
+}
+
+bool writeStr(int fd, const char *str) {
+    return writeAll(fd, str, strlen(str));
+}
+
+void selectWrapper(const char *diagName, int nfds, fd_set *readfds) {
+    int ret = select(nfds, readfds, NULL, NULL, NULL);
+    if (ret < 0) {
+        if (errno == EINTR) {
+            FD_ZERO(readfds);
+            return;
+        }
+#ifdef WINPTY_TARGET_MSYS1
+        // The select system call sometimes fails with EAGAIN instead of EINTR.
+        // This apparantly only happens with the old Cygwin fork "MSYS" used in
+        // the mingw.org project.  select is not supposed to fail with EAGAIN,
+        // and EAGAIN does not make much sense as an error code.  (The whole
+        // point of select is to block.)
+        if (errno == EAGAIN) {
+            trace("%s select returned EAGAIN: interpreting like EINTR",
+                diagName);
+            FD_ZERO(readfds);
+            return;
+        }
+#endif
+        fprintf(stderr, "Internal error: %s select failed: "
+            "error %d", diagName, errno);
+        abort();
+    }
+}

package/deps/winpty/src/unix-adapter/Util.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2015 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 UNIX_ADAPTER_UTIL_H
+#define UNIX_ADAPTER_UTIL_H
+
+#include <stdlib.h>
+#include <sys/select.h>
+
+bool writeAll(int fd, const void *buffer, size_t size);
+bool writeStr(int fd, const char *str);
+void selectWrapper(const char *diagName, int nfds, fd_set *readfds);
+
+#endif // UNIX_ADAPTER_UTIL_H

package/deps/winpty/src/unix-adapter/WakeupFd.cc

@@ -0,0 +1,70 @@
+// Copyright (c) 2011-2015 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 "WakeupFd.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static void setFdNonBlock(int fd) {
+    int status = fcntl(fd, F_GETFL);
+    fcntl(fd, F_SETFL, status | O_NONBLOCK);
+}
+
+WakeupFd::WakeupFd() {
+    int pipeFd[2];
+    if (pipe(pipeFd) != 0) {
+        perror("Could not create internal wakeup pipe");
+        abort();
+    }
+    m_pipeReadFd = pipeFd[0];
+    m_pipeWriteFd = pipeFd[1];
+    setFdNonBlock(m_pipeReadFd);
+    setFdNonBlock(m_pipeWriteFd);
+}
+
+WakeupFd::~WakeupFd() {
+    close(m_pipeReadFd);
+    close(m_pipeWriteFd);
+}
+
+void WakeupFd::set() {
+    char dummy = 0;
+    int ret;
+    do {
+        ret = write(m_pipeWriteFd, &dummy, 1);
+    } while (ret < 0 && errno == EINTR);
+}
+
+void WakeupFd::reset() {
+    char tmpBuf[256];
+    while (true) {
+        int amount = read(m_pipeReadFd, tmpBuf, sizeof(tmpBuf));
+        if (amount < 0 && errno == EAGAIN) {
+            break;
+        } else if (amount <= 0) {
+            perror("error reading from internal wakeup pipe");
+            abort();
+        }
+    }
+}