整理

include/boost/process/v1/detail/windows/async_pipe.hpp

@@ -0,0 +1,482 @@
+// Copyright (c) 2016 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PROCESS_DETAIL_WINDOWS_ASYNC_PIPE_HPP_
+#define BOOST_PROCESS_DETAIL_WINDOWS_ASYNC_PIPE_HPP_
+
+#include <boost/winapi/basic_types.hpp>
+#include <boost/winapi/pipes.hpp>
+#include <boost/winapi/handles.hpp>
+#include <boost/winapi/file_management.hpp>
+#include <boost/winapi/get_last_error.hpp>
+#include <boost/winapi/access_rights.hpp>
+#include <boost/winapi/process.hpp>
+#include <boost/process/v1/detail/windows/basic_pipe.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/asio/windows/stream_handle.hpp>
+#include <atomic>
+#include <system_error>
+#include <string>
+
+namespace boost { namespace process { BOOST_PROCESS_V1_INLINE namespace v1 { namespace detail { namespace windows {
+
+inline std::string make_pipe_name()
+{
+    std::string name = "\\\\.\\pipe\\boost_process_auto_pipe_";
+
+    auto pid = ::boost::winapi::GetCurrentProcessId();
+
+    static std::atomic_size_t cnt{0};
+    name += std::to_string(pid);
+    name += "_";
+    name += std::to_string(intptr_t(&cnt)); // to unclash Boost instances in plug-in DLLs
+    name += "_";
+    name += std::to_string(cnt++);
+
+    return name;
+}
+
+class async_pipe
+{
+    ::boost::asio::windows::stream_handle _source;
+    ::boost::asio::windows::stream_handle _sink  ;
+
+    inline async_pipe(boost::asio::io_context & ios_source,
+                      boost::asio::io_context & ios_sink,
+                      const std::string & name, bool private_);
+
+public:
+    typedef ::boost::winapi::HANDLE_ native_handle_type;
+    typedef ::boost::asio::windows::stream_handle   handle_type;
+    typedef typename handle_type::executor_type executor_type;
+
+    async_pipe(boost::asio::io_context & ios) : async_pipe(ios, ios, make_pipe_name(), true) {}
+    async_pipe(boost::asio::io_context & ios_source, boost::asio::io_context & ios_sink)
+                : async_pipe(ios_source, ios_sink, make_pipe_name(), true) {}
+
+    async_pipe(boost::asio::io_context & ios, const std::string & name)
+                : async_pipe(ios, ios, name, false) {}
+
+    async_pipe(boost::asio::io_context & ios_source, boost::asio::io_context & ios_sink, const std::string & name)
+            : async_pipe(ios_source, ios_sink, name, false) {}
+
+    inline async_pipe(const async_pipe& rhs);
+    async_pipe(async_pipe&& rhs)  : _source(std::move(rhs._source)), _sink(std::move(rhs._sink))
+    {
+    }
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    explicit async_pipe(::boost::asio::io_context & ios_source,
+                        ::boost::asio::io_context & ios_sink,
+                         const basic_pipe<CharT, Traits> & p)
+            : _source(ios_source, p.native_source()), _sink(ios_sink, p.native_sink())
+    {
+    }
+
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    explicit async_pipe(boost::asio::io_context & ios, const basic_pipe<CharT, Traits> & p)
+            : async_pipe(ios, ios, p)
+    {
+    }
+
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    inline async_pipe& operator=(const basic_pipe<CharT, Traits>& p);
+    inline async_pipe& operator=(const async_pipe& rhs);
+
+    inline async_pipe& operator=(async_pipe&& rhs);
+
+    ~async_pipe()
+    {
+        boost::system::error_code ec;
+        close(ec);
+    }
+
+    template<class CharT, class Traits = std::char_traits<CharT>>
+    inline explicit operator basic_pipe<CharT, Traits>() const;
+
+    void cancel()
+    {
+        if (_sink.is_open())
+            _sink.cancel();
+        if (_source.is_open())
+            _source.cancel();
+    }
+
+    void close()
+    {
+        if (_sink.is_open())
+        {
+            _sink.close();
+            _sink = handle_type(_sink.get_executor());
+        }
+        if (_source.is_open())
+        {
+            _source.close();
+            _source = handle_type(_source.get_executor());
+        }
+    }
+    void close(boost::system::error_code & ec)
+    {
+        if (_sink.is_open())
+        {
+            _sink.close(ec);
+            _sink = handle_type(_sink.get_executor());
+        }
+        if (_source.is_open())
+        {
+            _source.close(ec);
+            _source = handle_type(_source.get_executor());
+        }
+    }
+
+    bool is_open() const
+    {
+        return  _sink.is_open() || _source.is_open();
+    }
+    void async_close()
+    {
+        if (_sink.is_open())
+            boost::asio::post(_sink.get_executor(),   [this]{_sink.close();});
+        if (_source.is_open())
+            boost::asio::post(_source.get_executor(), [this]{_source.close();});
+    }
+
+    template<typename MutableBufferSequence>
+    std::size_t read_some(const MutableBufferSequence & buffers)
+    {
+        return _source.read_some(buffers);
+    }
+    template<typename MutableBufferSequence>
+    std::size_t write_some(const MutableBufferSequence & buffers)
+    {
+        return _sink.write_some(buffers);
+    }
+
+    template<typename MutableBufferSequence>
+    std::size_t read_some(const MutableBufferSequence & buffers, boost::system::error_code & ec) noexcept
+    {
+        return _source.read_some(buffers, ec);
+    }
+    template<typename MutableBufferSequence>
+    std::size_t write_some(const MutableBufferSequence & buffers, boost::system::error_code & ec) noexcept
+    {
+        return _sink.write_some(buffers, ec);
+    }
+
+    native_handle_type native_source() const {return const_cast<boost::asio::windows::stream_handle&>(_source).native_handle();}
+    native_handle_type native_sink  () const {return const_cast<boost::asio::windows::stream_handle&>(_sink  ).native_handle();}
+
+    template<typename MutableBufferSequence,
+             typename ReadHandler>
+    BOOST_ASIO_INITFN_RESULT_TYPE(
+          ReadHandler, void(boost::system::error_code, std::size_t))
+      async_read_some(
+        const MutableBufferSequence & buffers,
+              ReadHandler &&handler)
+    {
+        return _source.async_read_some(buffers, std::forward<ReadHandler>(handler));
+    }
+
+    template<typename ConstBufferSequence,
+             typename WriteHandler>
+    BOOST_ASIO_INITFN_RESULT_TYPE(
+              WriteHandler, void(boost::system::error_code, std::size_t))
+      async_write_some(
+        const ConstBufferSequence & buffers,
+        WriteHandler && handler)
+    {
+        return _sink.async_write_some(buffers,  std::forward<WriteHandler>(handler));
+    }
+
+    const handle_type & sink  () const & {return _sink;}
+    const handle_type & source() const & {return _source;}
+
+    handle_type && source() && { return std::move(_source); }
+    handle_type && sink()   && { return std::move(_sink); }
+
+    handle_type source(::boost::asio::io_context& ios) &&
+    {
+        ::boost::asio::windows::stream_handle stolen(ios.get_executor(), _source.native_handle());
+        boost::system::error_code ec;
+        _source.assign(::boost::winapi::INVALID_HANDLE_VALUE_, ec);
+        return stolen;
+    }
+    handle_type sink  (::boost::asio::io_context& ios) &&
+    {
+        ::boost::asio::windows::stream_handle stolen(ios.get_executor(), _sink.native_handle());
+        boost::system::error_code ec;
+        _sink.assign(::boost::winapi::INVALID_HANDLE_VALUE_, ec);
+        return stolen;
+    }
+
+    handle_type source(::boost::asio::io_context& ios) const &
+    {
+        auto proc = ::boost::winapi::GetCurrentProcess();
+
+        ::boost::winapi::HANDLE_ source;
+        auto source_in = const_cast<handle_type&>(_source).native_handle();
+        if (source_in == ::boost::winapi::INVALID_HANDLE_VALUE_)
+            source = ::boost::winapi::INVALID_HANDLE_VALUE_;
+        else if (!::boost::winapi::DuplicateHandle(
+                proc, source_in, proc, &source, 0,
+                static_cast<::boost::winapi::BOOL_>(true),
+                 ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+            throw_last_error("Duplicate Pipe Failed");
+
+        return ::boost::asio::windows::stream_handle(ios.get_executor(), source);
+    }
+    handle_type sink  (::boost::asio::io_context& ios) const &
+    {
+        auto proc = ::boost::winapi::GetCurrentProcess();
+
+        ::boost::winapi::HANDLE_ sink;
+        auto sink_in = const_cast<handle_type&>(_sink).native_handle();
+        if (sink_in == ::boost::winapi::INVALID_HANDLE_VALUE_)
+            sink = ::boost::winapi::INVALID_HANDLE_VALUE_;
+        else if (!::boost::winapi::DuplicateHandle(
+                proc, sink_in, proc, &sink, 0,
+                static_cast<::boost::winapi::BOOL_>(true),
+                 ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+            throw_last_error("Duplicate Pipe Failed");
+
+        return ::boost::asio::windows::stream_handle(ios.get_executor(), sink);
+    }
+};
+
+async_pipe::async_pipe(const async_pipe& p)  :
+    _source(const_cast<handle_type&>(p._source).get_executor()),
+    _sink  (const_cast<handle_type&>(p._sink).get_executor())
+{
+
+    auto proc = ::boost::winapi::GetCurrentProcess();
+
+    ::boost::winapi::HANDLE_ source;
+    ::boost::winapi::HANDLE_ sink;
+
+    //cannot get the handle from a const object.
+    auto source_in = const_cast<handle_type&>(p._source).native_handle();
+    auto sink_in   = const_cast<handle_type&>(p._sink).native_handle();
+
+    if (source_in == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        source = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, source_in, proc, &source, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+             ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    if (sink_in   == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        sink = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, sink_in, proc, &sink, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+             ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    if (source != ::boost::winapi::INVALID_HANDLE_VALUE_)
+        _source.assign(source);
+    if (sink != ::boost::winapi::INVALID_HANDLE_VALUE_)
+        _sink.  assign(sink);
+}
+
+async_pipe::async_pipe(boost::asio::io_context & ios_source,
+                       boost::asio::io_context & ios_sink,
+                       const std::string & name, bool private_) : _source(ios_source), _sink(ios_sink)
+{
+    static constexpr int FILE_FLAG_OVERLAPPED_  = 0x40000000; //temporary
+
+    ::boost::winapi::HANDLE_ source = ::boost::winapi::create_named_pipe(
+#if defined(BOOST_NO_ANSI_APIS)
+            ::boost::process::v1::detail::convert(name).c_str(),
+#else
+            name.c_str(),
+#endif
+            ::boost::winapi::PIPE_ACCESS_INBOUND_
+            | FILE_FLAG_OVERLAPPED_, //write flag
+            0, private_ ? 1 : ::boost::winapi::PIPE_UNLIMITED_INSTANCES_, 8192, 8192, 0, nullptr);
+
+    if (source == boost::winapi::INVALID_HANDLE_VALUE_)
+        ::boost::process::v1::detail::throw_last_error("create_named_pipe(" + name + ") failed");
+
+    _source.assign(source);
+
+    ::boost::winapi::HANDLE_ sink = boost::winapi::create_file(
+#if defined(BOOST_NO_ANSI_APIS)
+            ::boost::process::v1::detail::convert(name).c_str(),
+#else
+            name.c_str(),
+#endif
+            ::boost::winapi::GENERIC_WRITE_, 0, nullptr,
+            ::boost::winapi::OPEN_EXISTING_,
+            FILE_FLAG_OVERLAPPED_, //to allow read
+            nullptr);
+
+    if (sink == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        ::boost::process::v1::detail::throw_last_error("create_file() failed");
+
+    _sink.assign(sink);
+}
+
+template<class CharT, class Traits>
+async_pipe& async_pipe::operator=(const basic_pipe<CharT, Traits> & p)
+{
+    auto proc = ::boost::winapi::GetCurrentProcess();
+
+    ::boost::winapi::HANDLE_ source;
+    ::boost::winapi::HANDLE_ sink;
+
+    //cannot get the handle from a const object.
+    auto source_in = p.native_source();
+    auto sink_in   = p.native_sink();
+
+    if (source_in == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        source = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, source_in.native_handle(), proc, &source, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+            ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    if (sink_in   == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        sink = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, sink_in.native_handle(), proc, &sink, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+            ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    //so we also assign the io_context
+    if (source != ::boost::winapi::INVALID_HANDLE_VALUE_)
+        _source.assign(source);
+
+    if (sink != ::boost::winapi::INVALID_HANDLE_VALUE_)
+        _sink.assign(sink);
+
+    return *this;
+}
+
+async_pipe& async_pipe::operator=(const async_pipe & p)
+{
+    auto proc = ::boost::winapi::GetCurrentProcess();
+
+    ::boost::winapi::HANDLE_ source;
+    ::boost::winapi::HANDLE_ sink;
+
+    //cannot get the handle from a const object.
+    auto &source_in = const_cast<::boost::asio::windows::stream_handle &>(p._source);
+    auto &sink_in   = const_cast<::boost::asio::windows::stream_handle &>(p._sink);
+
+    source_in.get_executor();
+
+    if (source_in.native_handle() == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        source = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, source_in.native_handle(), proc, &source, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+             ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    if (sink_in.native_handle()   == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        sink = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, sink_in.native_handle(), proc, &sink, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+             ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    //so we also assign the io_context
+    if (source != ::boost::winapi::INVALID_HANDLE_VALUE_)
+        _source = ::boost::asio::windows::stream_handle(source_in.get_executor(), source);
+    else
+        _source = ::boost::asio::windows::stream_handle(source_in.get_executor());
+
+    if (sink != ::boost::winapi::INVALID_HANDLE_VALUE_)
+        _sink   = ::boost::asio::windows::stream_handle(source_in.get_executor(), sink);
+    else
+        _sink   = ::boost::asio::windows::stream_handle(source_in.get_executor());
+
+    return *this;
+}
+
+async_pipe& async_pipe::operator=(async_pipe && rhs)
+{
+    _source = std::move(rhs._source);
+    _sink = std::move(rhs._sink);
+    return *this;
+}
+
+template<class CharT, class Traits>
+async_pipe::operator basic_pipe<CharT, Traits>() const
+{
+    auto proc = ::boost::winapi::GetCurrentProcess();
+
+    ::boost::winapi::HANDLE_ source;
+    ::boost::winapi::HANDLE_ sink;
+
+    //cannot get the handle from a const object.
+    auto source_in = const_cast<::boost::asio::windows::stream_handle &>(_source).native_handle();
+    auto sink_in   = const_cast<::boost::asio::windows::stream_handle &>(_sink).native_handle();
+
+    if (source_in == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        source = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, source_in, proc, &source, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+             ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    if (sink_in == ::boost::winapi::INVALID_HANDLE_VALUE_)
+        sink = ::boost::winapi::INVALID_HANDLE_VALUE_;
+    else if (!::boost::winapi::DuplicateHandle(
+            proc, sink_in, proc, &sink, 0,
+            static_cast<::boost::winapi::BOOL_>(true),
+             ::boost::winapi::DUPLICATE_SAME_ACCESS_))
+        throw_last_error("Duplicate Pipe Failed");
+
+    return basic_pipe<CharT, Traits>{source, sink};
+}
+
+inline bool operator==(const async_pipe & lhs, const async_pipe & rhs)
+{
+    return compare_handles(lhs.native_source(), rhs.native_source()) &&
+           compare_handles(lhs.native_sink(),   rhs.native_sink());
+}
+
+inline bool operator!=(const async_pipe & lhs, const async_pipe & rhs)
+{
+    return !compare_handles(lhs.native_source(), rhs.native_source()) ||
+           !compare_handles(lhs.native_sink(),   rhs.native_sink());
+}
+
+template<class Char, class Traits>
+inline bool operator==(const async_pipe & lhs, const basic_pipe<Char, Traits> & rhs)
+{
+    return compare_handles(lhs.native_source(), rhs.native_source()) &&
+           compare_handles(lhs.native_sink(),   rhs.native_sink());
+}
+
+template<class Char, class Traits>
+inline bool operator!=(const async_pipe & lhs, const basic_pipe<Char, Traits> & rhs)
+{
+    return !compare_handles(lhs.native_source(), rhs.native_source()) ||
+           !compare_handles(lhs.native_sink(),   rhs.native_sink());
+}
+
+template<class Char, class Traits>
+inline bool operator==(const basic_pipe<Char, Traits> & lhs, const async_pipe & rhs)
+{
+    return compare_handles(lhs.native_source(), rhs.native_source()) &&
+           compare_handles(lhs.native_sink(),   rhs.native_sink());
+}
+
+template<class Char, class Traits>
+inline bool operator!=(const basic_pipe<Char, Traits> & lhs, const async_pipe & rhs)
+{
+    return !compare_handles(lhs.native_source(), rhs.native_source()) ||
+           !compare_handles(lhs.native_sink(),   rhs.native_sink());
+}
+
+}}}}}
+
+#endif /* INCLUDE_BOOST_PIPE_DETAIL_WINDOWS_ASYNC_PIPE_HPP_ */