@jingyi0605/codingns 0.8.0 → 0.8.5

package/vendor/node-pty-fork/deps/winpty/src/agent/NamedPipe.cc

@@ -0,0 +1,378 @@
+// 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 <string.h>
+
+#include <algorithm>
+
+#include "EventLoop.h"
+#include "NamedPipe.h"
+#include "../shared/DebugClient.h"
+#include "../shared/StringUtil.h"
+#include "../shared/WindowsSecurity.h"
+#include "../shared/WinptyAssert.h"
+
+// Returns true if anything happens (data received, data sent, pipe error).
+bool NamedPipe::serviceIo(std::vector<HANDLE> *waitHandles)
+{
+    bool justConnected = false;
+    const auto kError = ServiceResult::Error;
+    const auto kProgress = ServiceResult::Progress;
+    const auto kNoProgress = ServiceResult::NoProgress;
+    if (m_handle == NULL) {
+        return false;
+    }
+    if (m_connectEvent.get() != nullptr) {
+        // We're still connecting this server pipe.  Check whether the pipe is
+        // now connected.  If it isn't, add the pipe to the list of handles to
+        // wait on.
+        DWORD actual = 0;
+        BOOL success =
+            GetOverlappedResult(m_handle, &m_connectOver, &actual, FALSE);
+        if (!success && GetLastError() == ERROR_PIPE_CONNECTED) {
+            // I'm not sure this can happen, but it's easy to handle if it
+            // does.
+            success = TRUE;
+        }
+        if (!success) {
+            ASSERT(GetLastError() == ERROR_IO_INCOMPLETE &&
+                "Pended ConnectNamedPipe call failed");
+            waitHandles->push_back(m_connectEvent.get());
+        } else {
+            TRACE("Server pipe [%s] connected",
+                utf8FromWide(m_name).c_str());
+            m_connectEvent.dispose();
+            startPipeWorkers();
+            justConnected = true;
+        }
+    }
+    const auto readProgress = m_inputWorker ? m_inputWorker->service() : kNoProgress;
+    const auto writeProgress = m_outputWorker ? m_outputWorker->service() : kNoProgress;
+    if (readProgress == kError || writeProgress == kError) {
+        closePipe();
+        return true;
+    }
+    if (m_inputWorker && m_inputWorker->getWaitEvent() != nullptr) {
+        waitHandles->push_back(m_inputWorker->getWaitEvent());
+    }
+    if (m_outputWorker && m_outputWorker->getWaitEvent() != nullptr) {
+        waitHandles->push_back(m_outputWorker->getWaitEvent());
+    }
+    return justConnected
+        || readProgress == kProgress
+        || writeProgress == kProgress;
+}
+
+// manual reset, initially unset
+static OwnedHandle createEvent() {
+    HANDLE ret = CreateEventW(nullptr, TRUE, FALSE, nullptr);
+    ASSERT(ret != nullptr && "CreateEventW failed");
+    return OwnedHandle(ret);
+}
+
+NamedPipe::IoWorker::IoWorker(NamedPipe &namedPipe) :
+    m_namedPipe(namedPipe),
+    m_event(createEvent())
+{
+}
+
+NamedPipe::ServiceResult NamedPipe::IoWorker::service()
+{
+    ServiceResult progress = ServiceResult::NoProgress;
+    if (m_pending) {
+        DWORD actual = 0;
+        BOOL ret = GetOverlappedResult(m_namedPipe.m_handle, &m_over, &actual, FALSE);
+        if (!ret) {
+            if (GetLastError() == ERROR_IO_INCOMPLETE) {
+                // There is a pending I/O.
+                return progress;
+            } else {
+                // Pipe error.
+                return ServiceResult::Error;
+            }
+        }
+        ResetEvent(m_event.get());
+        m_pending = false;
+        completeIo(actual);
+        m_currentIoSize = 0;
+        progress = ServiceResult::Progress;
+    }
+    DWORD nextSize = 0;
+    bool isRead = false;
+    while (shouldIssueIo(&nextSize, &isRead)) {
+        m_currentIoSize = nextSize;
+        DWORD actual = 0;
+        memset(&m_over, 0, sizeof(m_over));
+        m_over.hEvent = m_event.get();
+        BOOL ret = isRead
+                ? ReadFile(m_namedPipe.m_handle, m_buffer, nextSize, &actual, &m_over)
+                : WriteFile(m_namedPipe.m_handle, m_buffer, nextSize, &actual, &m_over);
+        if (!ret) {
+            if (GetLastError() == ERROR_IO_PENDING) {
+                // There is a pending I/O.
+                m_pending = true;
+                return progress;
+            } else {
+                // Pipe error.
+                return ServiceResult::Error;
+            }
+        }
+        ResetEvent(m_event.get());
+        completeIo(actual);
+        m_currentIoSize = 0;
+        progress = ServiceResult::Progress;
+    }
+    return progress;
+}
+
+// This function is called after CancelIo has returned.  We need to block until
+// the I/O operations have completed, which should happen very quickly.
+// https://blogs.msdn.microsoft.com/oldnewthing/20110202-00/?p=11613
+void NamedPipe::IoWorker::waitForCanceledIo()
+{
+    if (m_pending) {
+        DWORD actual = 0;
+        GetOverlappedResult(m_namedPipe.m_handle, &m_over, &actual, TRUE);
+        m_pending = false;
+    }
+}
+
+HANDLE NamedPipe::IoWorker::getWaitEvent()
+{
+    return m_pending ? m_event.get() : NULL;
+}
+
+void NamedPipe::InputWorker::completeIo(DWORD size)
+{
+    m_namedPipe.m_inQueue.append(m_buffer, size);
+}
+
+bool NamedPipe::InputWorker::shouldIssueIo(DWORD *size, bool *isRead)
+{
+    *isRead = true;
+    ASSERT(!m_namedPipe.isConnecting());
+    if (m_namedPipe.isClosed()) {
+        return false;
+    } else if (m_namedPipe.m_inQueue.size() < m_namedPipe.readBufferSize()) {
+        *size = kIoSize;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void NamedPipe::OutputWorker::completeIo(DWORD size)
+{
+    ASSERT(size == m_currentIoSize);
+}
+
+bool NamedPipe::OutputWorker::shouldIssueIo(DWORD *size, bool *isRead)
+{
+    *isRead = false;
+    if (!m_namedPipe.m_outQueue.empty()) {
+        auto &out = m_namedPipe.m_outQueue;
+        const DWORD writeSize = std::min<size_t>(out.size(), kIoSize);
+        std::copy(&out[0], &out[writeSize], m_buffer);
+        out.erase(0, writeSize);
+        *size = writeSize;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+DWORD NamedPipe::OutputWorker::getPendingIoSize()
+{
+    return m_pending ? m_currentIoSize : 0;
+}
+
+void NamedPipe::openServerPipe(LPCWSTR pipeName, OpenMode::t openMode,
+                               int outBufferSize, int inBufferSize) {
+    ASSERT(isClosed());
+    ASSERT((openMode & OpenMode::Duplex) != 0);
+    const DWORD winOpenMode =
+              ((openMode & OpenMode::Reading) ? PIPE_ACCESS_INBOUND : 0)
+            | ((openMode & OpenMode::Writing) ? PIPE_ACCESS_OUTBOUND : 0)
+            | FILE_FLAG_FIRST_PIPE_INSTANCE
+            | FILE_FLAG_OVERLAPPED;
+    const auto sd = createPipeSecurityDescriptorOwnerFullControl();
+    ASSERT(sd && "error creating data pipe SECURITY_DESCRIPTOR");
+    SECURITY_ATTRIBUTES sa = {};
+    sa.nLength = sizeof(sa);
+    sa.lpSecurityDescriptor = sd.get();
+    HANDLE handle = CreateNamedPipeW(
+        pipeName,
+        /*dwOpenMode=*/winOpenMode,
+        /*dwPipeMode=*/rejectRemoteClientsPipeFlag(),
+        /*nMaxInstances=*/1,
+        /*nOutBufferSize=*/outBufferSize,
+        /*nInBufferSize=*/inBufferSize,
+        /*nDefaultTimeOut=*/30000,
+        &sa);
+    TRACE("opened server pipe [%s], handle == %p",
+        utf8FromWide(pipeName).c_str(), handle);
+    ASSERT(handle != INVALID_HANDLE_VALUE && "Could not open server pipe");
+    m_name = pipeName;
+    m_handle = handle;
+    m_openMode = openMode;
+
+    // Start an asynchronous connection attempt.
+    m_connectEvent = createEvent();
+    memset(&m_connectOver, 0, sizeof(m_connectOver));
+    m_connectOver.hEvent = m_connectEvent.get();
+    BOOL success = ConnectNamedPipe(m_handle, &m_connectOver);
+    const auto err = GetLastError();
+    if (!success && err == ERROR_PIPE_CONNECTED) {
+        success = TRUE;
+    }
+    if (success) {
+        TRACE("Server pipe [%s] connected", utf8FromWide(pipeName).c_str());
+        m_connectEvent.dispose();
+        startPipeWorkers();
+    } else if (err != ERROR_IO_PENDING) {
+        ASSERT(false && "ConnectNamedPipe call failed");
+    }
+}
+
+void NamedPipe::connectToServer(LPCWSTR pipeName, OpenMode::t openMode)
+{
+    ASSERT(isClosed());
+    ASSERT((openMode & OpenMode::Duplex) != 0);
+    HANDLE handle = CreateFileW(
+        pipeName,
+        GENERIC_READ | GENERIC_WRITE,
+        0,
+        NULL,
+        OPEN_EXISTING,
+        SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION | FILE_FLAG_OVERLAPPED,
+        NULL);
+    TRACE("connected to [%s], handle == %p",
+        utf8FromWide(pipeName).c_str(), handle);
+    ASSERT(handle != INVALID_HANDLE_VALUE && "Could not connect to pipe");
+    m_name = pipeName;
+    m_handle = handle;
+    m_openMode = openMode;
+    startPipeWorkers();
+}
+
+void NamedPipe::startPipeWorkers()
+{
+    if (m_openMode & OpenMode::Reading) {
+        m_inputWorker.reset(new InputWorker(*this));
+    }
+    if (m_openMode & OpenMode::Writing) {
+        m_outputWorker.reset(new OutputWorker(*this));
+    }
+}
+
+size_t NamedPipe::bytesToSend()
+{
+    ASSERT(m_openMode & OpenMode::Writing);
+    auto ret = m_outQueue.size();
+    if (m_outputWorker != NULL) {
+        ret += m_outputWorker->getPendingIoSize();
+    }
+    return ret;
+}
+
+void NamedPipe::write(const void *data, size_t size)
+{
+    ASSERT(m_openMode & OpenMode::Writing);
+    m_outQueue.append(reinterpret_cast<const char*>(data), size);
+}
+
+void NamedPipe::write(const char *text)
+{
+    write(text, strlen(text));
+}
+
+size_t NamedPipe::readBufferSize()
+{
+    ASSERT(m_openMode & OpenMode::Reading);
+    return m_readBufferSize;
+}
+
+void NamedPipe::setReadBufferSize(size_t size)
+{
+    ASSERT(m_openMode & OpenMode::Reading);
+    m_readBufferSize = size;
+}
+
+size_t NamedPipe::bytesAvailable()
+{
+    ASSERT(m_openMode & OpenMode::Reading);
+    return m_inQueue.size();
+}
+
+size_t NamedPipe::peek(void *data, size_t size)
+{
+    ASSERT(m_openMode & OpenMode::Reading);
+    const auto out = reinterpret_cast<char*>(data);
+    const size_t ret = std::min(size, m_inQueue.size());
+    std::copy(&m_inQueue[0], &m_inQueue[ret], out);
+    return ret;
+}
+
+size_t NamedPipe::read(void *data, size_t size)
+{
+    size_t ret = peek(data, size);
+    m_inQueue.erase(0, ret);
+    return ret;
+}
+
+std::string NamedPipe::readToString(size_t size)
+{
+    ASSERT(m_openMode & OpenMode::Reading);
+    size_t retSize = std::min(size, m_inQueue.size());
+    std::string ret = m_inQueue.substr(0, retSize);
+    m_inQueue.erase(0, retSize);
+    return ret;
+}
+
+std::string NamedPipe::readAllToString()
+{
+    ASSERT(m_openMode & OpenMode::Reading);
+    std::string ret = m_inQueue;
+    m_inQueue.clear();
+    return ret;
+}
+
+void NamedPipe::closePipe()
+{
+    if (m_handle == NULL) {
+        return;
+    }
+    CancelIo(m_handle);
+    if (m_connectEvent.get() != nullptr) {
+        DWORD actual = 0;
+        GetOverlappedResult(m_handle, &m_connectOver, &actual, TRUE);
+        m_connectEvent.dispose();
+    }
+    if (m_inputWorker) {
+        m_inputWorker->waitForCanceledIo();
+        m_inputWorker.reset();
+    }
+    if (m_outputWorker) {
+        m_outputWorker->waitForCanceledIo();
+        m_outputWorker.reset();
+    }
+    CloseHandle(m_handle);
+    m_handle = NULL;
+}

package/vendor/node-pty-fork/deps/winpty/src/agent/NamedPipe.h

@@ -0,0 +1,125 @@
+// 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 NAMEDPIPE_H
+#define NAMEDPIPE_H
+
+#include <windows.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "../shared/OwnedHandle.h"
+
+class EventLoop;
+
+class NamedPipe
+{
+private:
+    // The EventLoop uses these private members.
+    friend class EventLoop;
+    NamedPipe() {}
+    ~NamedPipe() { closePipe(); }
+    bool serviceIo(std::vector<HANDLE> *waitHandles);
+    void startPipeWorkers();
+
+    enum class ServiceResult { NoProgress, Error, Progress };
+
+private:
+    class IoWorker
+    {
+    public:
+        IoWorker(NamedPipe &namedPipe);
+        virtual ~IoWorker() {}
+        ServiceResult service();
+        void waitForCanceledIo();
+        HANDLE getWaitEvent();
+    protected:
+        NamedPipe &m_namedPipe;
+        bool m_pending = false;
+        DWORD m_currentIoSize = 0;
+        OwnedHandle m_event;
+        OVERLAPPED m_over = {};
+        enum { kIoSize = 64 * 1024 };
+        char m_buffer[kIoSize];
+        virtual void completeIo(DWORD size) = 0;
+        virtual bool shouldIssueIo(DWORD *size, bool *isRead) = 0;
+    };
+
+    class InputWorker : public IoWorker
+    {
+    public:
+        InputWorker(NamedPipe &namedPipe) : IoWorker(namedPipe) {}
+    protected:
+        virtual void completeIo(DWORD size) override;
+        virtual bool shouldIssueIo(DWORD *size, bool *isRead) override;
+    };
+
+    class OutputWorker : public IoWorker
+    {
+    public:
+        OutputWorker(NamedPipe &namedPipe) : IoWorker(namedPipe) {}
+        DWORD getPendingIoSize();
+    protected:
+        virtual void completeIo(DWORD size) override;
+        virtual bool shouldIssueIo(DWORD *size, bool *isRead) override;
+    };
+
+public:
+    struct OpenMode {
+        typedef int t;
+        enum { None = 0, Reading = 1, Writing = 2, Duplex = 3 };
+    };
+
+    std::wstring name() const { return m_name; }
+    void openServerPipe(LPCWSTR pipeName, OpenMode::t openMode,
+                        int outBufferSize, int inBufferSize);
+    void connectToServer(LPCWSTR pipeName, OpenMode::t openMode);
+    size_t bytesToSend();
+    void write(const void *data, size_t size);
+    void write(const char *text);
+    size_t readBufferSize();
+    void setReadBufferSize(size_t size);
+    size_t bytesAvailable();
+    size_t peek(void *data, size_t size);
+    size_t read(void *data, size_t size);
+    std::string readToString(size_t size);
+    std::string readAllToString();
+    void closePipe();
+    bool isClosed() { return m_handle == nullptr; }
+    bool isConnected() { return !isClosed() && !isConnecting(); }
+    bool isConnecting() { return m_connectEvent.get() != nullptr; }
+
+private:
+    // Input/output buffers
+    std::wstring m_name;
+    OVERLAPPED m_connectOver = {};
+    OwnedHandle m_connectEvent;
+    OpenMode::t m_openMode = OpenMode::None;
+    size_t m_readBufferSize = 64 * 1024;
+    std::string m_inQueue;
+    std::string m_outQueue;
+    HANDLE m_handle = nullptr;
+    std::unique_ptr<InputWorker> m_inputWorker;
+    std::unique_ptr<OutputWorker> m_outputWorker;
+};
+
+#endif // NAMEDPIPE_H