started on asio_no_deprecated.cpp

doc/tutorial.qbk

@@ -158,7 +158,7 @@ will change the behaviour, so that instead of throwing an exception, the error w
 
 ```
 std::error_code ec;
-bp::system("g++ main.cpp", ec);
+bp::system c("g++ main.cpp", ec);
 ```
 [endsect]
 [section:io Synchronous I/O]
@@ -296,7 +296,7 @@ provided we also pass a reference to an io_service.
 
 ```
 io_service ios;
-std::vector<char> buf(4096);
+std::vector<char> buf;
 
 bp::child c(bp::search_path("g++"), "main.cpp", bp::std_out > asio_buffer(buf), ios);
 

include/boost/process/async_system.hpp

@@ -82,7 +82,7 @@ struct async_system_handler : ::boost::process::detail::api::async_handler
     {
 #if defined(BOOST_POSIX_API)
         if (errored)
-            return [](int , const std::error_code &){};
+            return [](int exit_code, const std::error_code & ec){};
 #endif
         auto & h = init.completion_handler;
         return [h](int exit_code, const std::error_code & ec) mutable

include/boost/process/detail/posix/async_in.hpp

@@ -39,7 +39,7 @@ struct async_in_buffer : ::boost::process::detail::posix::handler_base_ext,
     {
     }
     template <typename Executor>
-    inline void on_success(Executor)
+    inline void on_success(Executor &exec)
     {
         auto  pipe              = this->pipe;
         if (this->promise)
@@ -60,7 +60,7 @@ struct async_in_buffer : ::boost::process::detail::posix::handler_base_ext,
         }
         else
             boost::asio::async_write(*pipe, buf,
-                [pipe](const boost::system::error_code&, std::size_t){});
+                [pipe](const boost::system::error_code&ec, std::size_t size){});
 
         std::move(*pipe).source().close();
 

include/boost/process/detail/posix/async_out.hpp

@@ -61,7 +61,7 @@ struct async_out_buffer : ::boost::process::detail::posix::handler_base_ext,
     {
         auto  pipe              = this->pipe;
         boost::asio::async_read(*pipe, buf,
-                [pipe](const boost::system::error_code&, std::size_t){});
+                [pipe](const boost::system::error_code&, std::size_t size){});
 
         this->pipe = nullptr;
         std::move(*pipe).sink().close();
@@ -112,7 +112,7 @@ struct async_out_future : ::boost::process::detail::posix::handler_base_ext,
         fut = promise->get_future();
     }
     template <typename Executor>
-    inline void on_success(Executor &)
+    inline void on_success(Executor &exec)
     {
         auto pipe = this->pipe;
 
@@ -120,7 +120,7 @@ struct async_out_future : ::boost::process::detail::posix::handler_base_ext,
         auto promise = this->promise;
 
         boost::asio::async_read(*pipe, *buffer,
-                [pipe, buffer, promise](const boost::system::error_code& ec, std::size_t)
+                [pipe, buffer, promise](const boost::system::error_code& ec, std::size_t size)
                 {
                     if (ec && (ec.value() != ENOENT))
                     {

include/boost/process/detail/posix/async_pipe.hpp

@@ -125,18 +125,6 @@ public:
         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::posix::stream_descriptor&>(_source).native_handle();}
     native_handle_type native_sink  () const {return const_cast<boost::asio::posix::stream_descriptor&>(_sink  ).native_handle();}
 
@@ -148,7 +136,7 @@ public:
         const MutableBufferSequence & buffers,
               ReadHandler &&handler)
     {
-        return _source.async_read_some(buffers, std::forward<ReadHandler>(handler));
+        _source.async_read_some(buffers, std::forward<ReadHandler>(handler));
     }
 
     template<typename ConstBufferSequence,
@@ -159,7 +147,7 @@ public:
         const ConstBufferSequence & buffers,
         WriteHandler&& handler)
     {
-        return _sink.async_write_some(buffers, std::forward<WriteHandler>(handler));
+        _sink.async_write_some(buffers, std::forward<WriteHandler>(handler));
     }
 
 
@@ -250,8 +238,8 @@ async_pipe& async_pipe::operator=(const async_pipe & p)
     int sink;
 
     //cannot get the handle from a const object.
-    auto source_in = const_cast<::boost::asio::posix::stream_descriptor &>(p._source).native_handle();
-    auto sink_in   = const_cast<::boost::asio::posix::stream_descriptor &>(p._sink).native_handle();
+    auto source_in = const_cast<::boost::asio::posix::stream_descriptor &>(_source).native_handle();
+    auto sink_in   = const_cast<::boost::asio::posix::stream_descriptor &>(_sink).native_handle();
     if (source_in == -1)
         source = -1;
     else

include/boost/process/detail/posix/executor.hpp

@@ -45,7 +45,7 @@ inline int execvpe(const char* filename, char * const arg_list[], char* env[])
 
         if (e != nullptr)
         {
-            std::vector<std::string> path;
+            std::vector<std::string> path; 
             boost::split(path, *e, boost::is_any_of(":"));
 
             for (const std::string & pp : path)
@@ -85,7 +85,7 @@ struct on_error_t
     template<typename T>
     void operator()(T & t) const
     {
-        t.on_error(exec, error);
+           t.on_error(exec, error);
     }
 };
 
@@ -157,13 +157,13 @@ struct on_fork_success_t
 };
 
 template<typename Executor> on_setup_t  <Executor> call_on_setup  (Executor & exec) {return exec;}
-template<typename Executor> on_error_t  <Executor> call_on_error  (Executor & exec, const std::error_code & ec)
+template<typename Executor> on_error_t  <Executor> call_on_error  (Executor & exec, const std::error_code & ec) 
 {
     return on_error_t<Executor> (exec, ec);
 }
 template<typename Executor> on_success_t<Executor> call_on_success(Executor & exec) {return exec;}
 
-template<typename Executor> on_fork_error_t  <Executor> call_on_fork_error  (Executor & exec, const std::error_code & ec)
+template<typename Executor> on_fork_error_t  <Executor> call_on_fork_error  (Executor & exec, const std::error_code & ec) 
 {
     return on_fork_error_t<Executor> (exec, ec);
 }
@@ -293,14 +293,10 @@ class executor
             auto err = errno;
             if ((err == EBADF) || (err == EPERM))//that should occur on success, therefore return.
                 return;
-                //EAGAIN not yet forked, EINTR interrupted, i.e. try again
+            //EAGAIN not yet forked, EINTR interrupted, i.e. try again
             else if ((err != EAGAIN ) && (err != EINTR))
-            {
-                ::close(source);
                 set_error(std::error_code(err, std::system_category()), "Error read pipe");
-            }
         }
-        ::close(source);
         set_error(ec, std::move(msg));
     }
 
@@ -380,10 +376,7 @@ child executor<Sequence>::invoke(boost::mpl::false_, boost::mpl::false_)
     }
     if (::fcntl(p[1], F_SETFD, FD_CLOEXEC) == -1)
     {
-        auto err = ::boost::process::detail::get_last_error();
-        ::close(p[0]);
-        ::close(p[1]);
-        set_error(err, "fcntl(2) failed");
+        set_error(::boost::process::detail::get_last_error(), "fcntl(2) failed");
         return child();
     }
     _ec.clear();
@@ -427,8 +420,11 @@ child executor<Sequence>::invoke(boost::mpl::false_, boost::mpl::false_)
 
     child c(child_handle(pid), exit_status);
 
+
+
     ::close(p[1]);
     _read_error(p[0]);
+    ::close(p[0]);
 
     if (_ec)
     {

include/boost/process/detail/posix/group_handle.hpp

@@ -56,7 +56,7 @@ struct group_handle
     {
         return ::getpgid(proc) == grp;
     }
-    bool has(handle_t proc, std::error_code &) noexcept
+    bool has(handle_t proc, std::error_code & ec) noexcept
     {
         return ::getpgid(proc) == grp;
     }

include/boost/process/detail/posix/sigchld_service.hpp

@@ -104,7 +104,8 @@ void sigchld_service::_handle_signal(const boost::system::error_code & ec)
         _signal_set.async_wait(
             [this](const boost::system::error_code & ec, int)
             {
-                _strand.post([this, ec]{this->_handle_signal(ec);});
+                _strand.post([ec]{});
+                this->_handle_signal(ec);
             });
     }
 }

include/boost/process/detail/posix/wait_for_exit.hpp

@@ -28,8 +28,7 @@ inline void wait(const child_handle &p, int & exit_code, std::error_code &ec) no
     {
         ret = ::waitpid(p.pid, &status, 0);
     } 
-    while (((ret == -1) && (errno == EINTR)) || 
-           (ret != -1 && !WIFEXITED(status) && !WIFSIGNALED(status)));
+    while (((ret == -1) && (errno == EINTR)) || (ret != -1 && !WIFEXITED(status) && !WIFSIGNALED(status)));
 
     if (ret == -1)
         ec = boost::process::detail::get_last_error();
@@ -54,43 +53,14 @@ inline bool wait_until(
         const std::chrono::time_point<Clock, Duration>& time_out,
         std::error_code & ec) noexcept
 {
-
-    ::sigset_t  sigset;
-
-    ::sigemptyset(&sigset);
-    ::sigaddset(&sigset, SIGCHLD);
-
-    auto get_timespec = 
-            [](const Duration & dur)
-            {
-                ::timespec ts;
-                ts.tv_sec  = std::chrono::duration_cast<std::chrono::seconds>(dur).count();
-                ts.tv_nsec = std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count() % 1000000000;
-                return ts;
-            };
-
     pid_t ret;
     int status;
 
-    struct ::sigaction old_sig;
-    if (-1 == ::sigaction(SIGCHLD, nullptr, &old_sig))
-    {
-        ec = get_last_error();
-        return false;
-    }
-
     bool timed_out;
 
     do
     {
-        auto ts = get_timespec(time_out - Clock::now());
-        auto ret_sig = ::sigtimedwait(&sigset, nullptr, &ts);
-        errno = 0;
         ret = ::waitpid(p.pid, &status, WNOHANG);
-
-        if ((ret_sig == SIGCHLD) && (old_sig.sa_handler != SIG_DFL) && (old_sig.sa_handler != SIG_IGN))
-            old_sig.sa_handler(ret);
-
         if (ret == 0)
         {
             timed_out = Clock::now() >= time_out;
@@ -117,7 +87,7 @@ template< class Clock, class Duration >
 inline bool wait_until(
         const child_handle &p,
         int & exit_code,
-        const std::chrono::time_point<Clock, Duration>& time_out)
+        const std::chrono::time_point<Clock, Duration>& time_out) noexcept
 {
     std::error_code ec;
     bool b = wait_until(p, exit_code, time_out, ec);
@@ -139,7 +109,7 @@ template< class Rep, class Period >
 inline bool wait_for(
         const child_handle &p,
         int & exit_code,
-        const std::chrono::duration<Rep, Period>& rel_time)
+        const std::chrono::duration<Rep, Period>& rel_time) noexcept
 {
     std::error_code ec;
     bool b = wait_for(p, exit_code, rel_time, ec);

include/boost/process/detail/posix/wait_group.hpp

@@ -22,23 +22,15 @@ namespace boost { namespace process { namespace detail { namespace posix {
 inline void wait(const group_handle &p, std::error_code &ec) noexcept
 {
     pid_t ret;
-    siginfo_t  status;
+    int status;
 
     do
     {
-        ret = ::waitpid(-p.grp, &status.si_status, 0);
-        if (ret == -1)
-        {
-            ec = get_last_error();
-            return; 
-        }
-
-        //ECHILD --> no child processes left.
-        ret = ::waitid(P_PGID, p.grp, &status, WEXITED | WNOHANG);
+        ret = ::waitpid(-p.grp, &status, 0);
     } 
-    while ((ret != -1) || (errno != ECHILD));
-   
-    if (errno != ECHILD)
+    while (((ret == -1) && (errno == EINTR)) || (ret != -1 && !WIFEXITED(status) && !WIFSIGNALED(status)));
+
+    if (ret == -1)
         ec = boost::process::detail::get_last_error();
     else
         ec.clear();
@@ -57,66 +49,31 @@ inline bool wait_until(
         const std::chrono::time_point<Clock, Duration>& time_out,
         std::error_code & ec) noexcept
 {
+    pid_t ret;
+    int status;
 
-    ::sigset_t  sigset;
-    ::siginfo_t siginfo;
-
-    ::sigemptyset(&sigset);
-    ::sigaddset(&sigset, SIGCHLD);
-
-    auto get_timespec = 
-            [](const Duration & dur)
-            {
-                ::timespec ts;
-                ts.tv_sec  = std::chrono::duration_cast<std::chrono::seconds>(dur).count();
-                ts.tv_nsec = std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count() % 1000000000;
-                return ts;
-            };
-
-
-    bool timed_out = false;
-    int ret;
-
-    struct ::sigaction old_sig;
-    if (-1 == ::sigaction(SIGCHLD, nullptr, &old_sig))
-    {
-        ec = get_last_error();
-        return false;
-    }
+    bool timed_out;
 
     do
     {
-        auto ts = get_timespec(time_out - Clock::now());
-        ret = ::sigtimedwait(&sigset, nullptr, &ts);
-        errno = 0;
-        if ((ret == SIGCHLD) && (old_sig.sa_handler != SIG_DFL) && (old_sig.sa_handler != SIG_IGN))
-            old_sig.sa_handler(ret);
-
-        ret = ::waitpid(-p.grp, &siginfo.si_status, 0); //so in case it exited, we wanna reap it first
-        if (ret == -1)
+        ret = ::waitpid(-p.grp, &status, WNOHANG);
+        if (ret == 0)
         {
-            ec = get_last_error();
-            return false; 
+            timed_out = Clock::now() >= time_out;
+            if (timed_out)
+                return false;
         }
+    }
+    while ((ret == 0) ||
+          (((ret == -1) && errno == EINTR) ||
+           ((ret != -1) && !WIFEXITED(status) && !WIFSIGNALED(status))));
 
-
-        //check if we're done
-        ret = ::waitid(P_PGID, p.grp, &siginfo, WEXITED | WNOHANG);
-
-    } 
-    while (((ret != -1) || (errno != ECHILD)) && !(timed_out = (Clock::now() > time_out)))  ;
-   
-    if (errno != ECHILD)
-    {
+    if (ret == -1)
         ec = boost::process::detail::get_last_error();
-        return !timed_out;
-    }
     else
-    {
         ec.clear();
-        return true; //even if timed out, there are no child proccessess left
-    }
 
+    return true;
 }
 
 template< class Clock, class Duration >

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

@@ -144,18 +144,6 @@ public:
         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();}
 
@@ -167,7 +155,7 @@ public:
         const MutableBufferSequence & buffers,
               ReadHandler &&handler)
     {
-        return _source.async_read_some(buffers, std::forward<ReadHandler>(handler));
+        _source.async_read_some(buffers, std::forward<ReadHandler>(handler));
     }
 
     template<typename ConstBufferSequence,
@@ -178,7 +166,7 @@ public:
         const ConstBufferSequence & buffers,
         WriteHandler && handler)
     {
-        return _sink.async_write_some(buffers,  std::forward<WriteHandler>(handler));
+        _sink.async_write_some(buffers,  std::forward<WriteHandler>(handler));
     }
 
     const handle_type & sink  () const & {return _sink;}

include/boost/process/detail/windows/executor.hpp

@@ -84,7 +84,7 @@ struct startup_info_impl
     void set_startup_info_ex()
     {
        startup_info.cb = sizeof(startup_info_ex_t);
-       creation_flags |= ::boost::winapi::EXTENDED_STARTUPINFO_PRESENT_;
+       creation_flags  = ::boost::winapi::EXTENDED_STARTUPINFO_PRESENT_;
     }
 };
 

include/boost/process/detail/windows/group_handle.hpp

@@ -84,37 +84,22 @@ inline void enable_break_away(::boost::winapi::HANDLE_ h, std::error_code & ec)
         ec = get_last_error();
         return;
     }
+
+
 }
 
-inline void associate_completion_port(::boost::winapi::HANDLE_ job,
-                                      ::boost::winapi::HANDLE_ io_port)
-{
-    workaround::JOBOBJECT_ASSOCIATE_COMPLETION_PORT_ port;
-    port.CompletionKey  = job;
-    port.CompletionPort = io_port;
-
-    if (!workaround::set_information_job_object(
-            job,
-            workaround::JobObjectAssociateCompletionPortInformation_,
-            static_cast<void*>(&port),
-            sizeof(port)))
-        throw_last_error("SetInformationJobObject() failed");
-}
 
 struct group_handle
 {
     ::boost::winapi::HANDLE_ _job_object;
-    ::boost::winapi::HANDLE_ _io_port;
 
     typedef ::boost::winapi::HANDLE_ handle_t;
     handle_t handle() const { return _job_object; }
 
     explicit group_handle(handle_t h) :
-        _job_object(h),
-        _io_port(::CreateIoCompletionPort(::boost::winapi::INVALID_HANDLE_VALUE_, nullptr, 0, 1))
+        _job_object(h)
     {
         enable_break_away(_job_object);
-        associate_completion_port(_job_object, _io_port);
     }
 
 
@@ -125,21 +110,15 @@ struct group_handle
     ~group_handle()
     {
         ::boost::winapi::CloseHandle(_job_object);
-        ::boost::winapi::CloseHandle(_io_port);
     }
     group_handle(const group_handle & c) = delete;
-    group_handle(group_handle && c) : _job_object(c._job_object),
-        _io_port(c._io_port)
+    group_handle(group_handle && c) : _job_object(c._job_object)
     {
         c._job_object = ::boost::winapi::invalid_handle_value;
-        c._io_port    = ::boost::winapi::invalid_handle_value;
     }
     group_handle &operator=(const group_handle & c) = delete;
     group_handle &operator=(group_handle && c)
     {
-        ::boost::winapi::CloseHandle(_io_port);
-        _io_port = c._io_port;
-        c._io_port = ::boost::winapi::invalid_handle_value;
 
         ::boost::winapi::CloseHandle(_job_object);
         _job_object = c._job_object;

include/boost/process/detail/windows/job_workaround.hpp

@@ -9,184 +9,68 @@
 #include <boost/winapi/config.hpp>
 #include <boost/winapi/basic_types.hpp>
 #include <boost/winapi/dll.hpp>
-#include <boost/winapi/overlapped.hpp>
 
-#if defined( BOOST_USE_WINDOWS_H )
-#include <windows.h>
-#else
-extern "C"
-{
-BOOST_SYMBOL_IMPORT ::boost::winapi::HANDLE_ BOOST_WINAPI_WINAPI_CC CreateIoCompletionPort(
-        ::boost::winapi::HANDLE_    FileHandle,
-        ::boost::winapi::HANDLE_    ExistingCompletionPort,
-        ::boost::winapi::ULONG_PTR_ CompletionKey,
-        ::boost::winapi::DWORD_     NumberOfConcurrentThreads
-);
-
-BOOST_SYMBOL_IMPORT ::boost::winapi::BOOL_ BOOST_WINAPI_WINAPI_CC GetQueuedCompletionStatus(
-        ::boost::winapi::HANDLE_       CompletionPort,
-        ::boost::winapi::LPDWORD_      lpNumberOfBytes,
-        ::boost::winapi::ULONG_PTR_    *lpCompletionKey,
-        _OVERLAPPED **lpOverlapped,
-        ::boost::winapi::DWORD_        dwMilliseconds
-);
-
-}
-#endif
 namespace boost { namespace process { namespace detail { namespace windows { namespace workaround {
 
-extern "C"
-{
-
-struct JOBOBJECT_ASSOCIATE_COMPLETION_PORT_
-{
-    ::boost::winapi::PVOID_  CompletionKey;
-    ::boost::winapi::HANDLE_ CompletionPort;
-};
-
-constexpr static int JOB_OBJECT_MSG_END_OF_JOB_TIME_          = 1;
-constexpr static int JOB_OBJECT_MSG_END_OF_PROCESS_TIME_      = 2;
-constexpr static int JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT_     = 3;
-constexpr static int JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO_      = 4;
-constexpr static int JOB_OBJECT_MSG_NEW_PROCESS_              = 6;
-constexpr static int JOB_OBJECT_MSG_EXIT_PROCESS_             = 7;
-constexpr static int JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS_    = 8;
-constexpr static int JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT_     = 9;
-constexpr static int JOB_OBJECT_MSG_JOB_MEMORY_LIMIT_         = 10;
-constexpr static int JOB_OBJECT_MSG_NOTIFICATION_LIMIT_       = 11;
-constexpr static int JOB_OBJECT_MSG_JOB_CYCLE_TIME_LIMIT_     = 12;
-constexpr static int JOB_OBJECT_MSG_SILO_TERMINATED_          = 13;
-
-}
-
-BOOST_FORCEINLINE ::boost::winapi::BOOL_  get_queued_completion_status(
-        ::boost::winapi::HANDLE_       CompletionPort,
-        ::boost::winapi::LPDWORD_      lpNumberOfBytes,
-        ::boost::winapi::ULONG_PTR_    *lpCompletionKey,
-        ::boost::winapi::LPOVERLAPPED_ *lpOverlapped,
-        ::boost::winapi::DWORD_        dwMilliseconds)
-{
-    return ::GetQueuedCompletionStatus(
-                CompletionPort,
-                lpNumberOfBytes,
-                lpCompletionKey,
-                reinterpret_cast<::_OVERLAPPED**>(lpOverlapped),
-                dwMilliseconds);
-}
-
-#if defined( BOOST_USE_WINDOWS_H )
-
-constexpr auto static JobObjectExtendedLimitInformation_ = ::JobObjectExtendedLimitInformation;
-constexpr auto static JobObjectAssociateCompletionPortInformation_ = ::JobObjectAssociateCompletionPortInformation;
-constexpr auto static JobObjectBasicAccountingInformation_ = ::JobObjectBasicAccountingInformation;
-
-using JOBOBJECT_BASIC_LIMIT_INFORMATION_ = ::JOBOBJECT_BASIC_LIMIT_INFORMATION;
-using JOBOBJECTINFOCLASS_ = ::JOBOBJECTINFOCLASS;
-using IO_COUNTERS_ = ::IO_COUNTERS;
-using JOBOBJECT_EXTENDED_LIMIT_INFORMATION_ = ::JOBOBJECT_EXTENDED_LIMIT_INFORMATION;
-using JOBOBJECT_BASIC_ACCOUNTING_INFORMATION_ = ::JOBOBJECT_BASIC_ACCOUNTING_INFORMATION;
-
-inline ::boost::winapi::BOOL_ query_information_job_object(
-        ::boost::winapi::HANDLE_ hJob,
-        JOBOBJECTINFOCLASS_ JobObjectInfoClass,
-        void * lpJobObjectInfo,
-        ::boost::winapi::DWORD_ cbJobObjectInfoLength,
-        ::boost::winapi::DWORD_ *lpReturnLength)
-{
-    return ::QueryInformationJobObject(hJob, JobObjectInfoClass, lpJobObjectInfo, cbJobObjectInfoLength, lpReturnLength);
-}
-
-inline ::boost::winapi::BOOL_ set_information_job_object(
-        ::boost::winapi::HANDLE_ hJob,
-        JOBOBJECTINFOCLASS_ JobObjectInfoClass,
-        void * lpJobObjectInfo,
-        ::boost::winapi::DWORD_ cbJobObjectInfoLength)
-{
-    return ::SetInformationJobObject(hJob, JobObjectInfoClass, lpJobObjectInfo, cbJobObjectInfoLength);
-}
-
-
-#else
-
 //this import workaround is to keep it a header-only library. and enums cannot be imported from the winapi.
 
 extern "C"
 {
 
-typedef enum _JOBOBJECTINFOCLASS_
-{
-    JobObjectBasicAccountingInformation_ = 1,
-    JobObjectBasicLimitInformation_,
-    JobObjectBasicProcessIdList_,
-    JobObjectBasicUIRestrictions_,
-    JobObjectSecurityLimitInformation_,
-    JobObjectEndOfJobTimeInformation_,
-    JobObjectAssociateCompletionPortInformation_,
-    JobObjectBasicAndIoAccountingInformation_,
-    JobObjectExtendedLimitInformation_,
-    JobObjectJobSetInformation_,
-    JobObjectGroupInformation_,
-    JobObjectNotificationLimitInformation_,
-    JobObjectLimitViolationInformation_,
-    JobObjectGroupInformationEx_,
-    JobObjectCpuRateControlInformation_,
-    JobObjectCompletionFilter_,
-    JobObjectCompletionCounter_,
-    JobObjectReserved1Information_ = 18,
-    JobObjectReserved2Information_,
-    JobObjectReserved3Information_,
-    JobObjectReserved4Information_,
-    JobObjectReserved5Information_,
-    JobObjectReserved6Information_,
-    JobObjectReserved7Information_,
-    JobObjectReserved8Information_,
-    MaxJobObjectInfoClass_
-} JOBOBJECTINFOCLASS_;
+typedef enum _JOBOBJECTINFOCLASS_ {
+      JobObjectBasicAccountingInformation_ = 1, JobObjectBasicLimitInformation_,
+      JobObjectBasicProcessIdList_, JobObjectBasicUIRestrictions_,
+      JobObjectSecurityLimitInformation_, JobObjectEndOfJobTimeInformation_,
+      JobObjectAssociateCompletionPortInformation_, JobObjectBasicAndIoAccountingInformation_,
+      JobObjectExtendedLimitInformation_, JobObjectJobSetInformation_,
+      JobObjectGroupInformation_,
+      JobObjectNotificationLimitInformation_,
+      JobObjectLimitViolationInformation_,
+      JobObjectGroupInformationEx_,
+      JobObjectCpuRateControlInformation_,
+      JobObjectCompletionFilter_,
+      JobObjectCompletionCounter_,
+      JobObjectReserved1Information_ = 18,
+      JobObjectReserved2Information_,
+      JobObjectReserved3Information_,
+      JobObjectReserved4Information_,
+      JobObjectReserved5Information_,
+      JobObjectReserved6Information_,
+      JobObjectReserved7Information_,
+      JobObjectReserved8Information_,
+      MaxJobObjectInfoClass_
+    } JOBOBJECTINFOCLASS_;
 
-typedef struct _JOBOBJECT_BASIC_LIMIT_INFORMATION_
-{
-    ::boost::winapi::LARGE_INTEGER_ PerProcessUserTimeLimit;
-    ::boost::winapi::LARGE_INTEGER_ PerJobUserTimeLimit;
-    ::boost::winapi::DWORD_ LimitFlags;
-    ::boost::winapi::SIZE_T_ MinimumWorkingSetSize;
-    ::boost::winapi::SIZE_T_ MaximumWorkingSetSize;
-    ::boost::winapi::DWORD_ ActiveProcessLimit;
-    ::boost::winapi::ULONG_PTR_ Affinity;
-    ::boost::winapi::DWORD_ PriorityClass;
-    ::boost::winapi::DWORD_ SchedulingClass;
+typedef struct _JOBOBJECT_BASIC_LIMIT_INFORMATION_ {
+  ::boost::winapi::LARGE_INTEGER_ PerProcessUserTimeLimit;
+  ::boost::winapi::LARGE_INTEGER_ PerJobUserTimeLimit;
+  ::boost::winapi::DWORD_         LimitFlags;
+  ::boost::winapi::SIZE_T_        MinimumWorkingSetSize;
+  ::boost::winapi::SIZE_T_        MaximumWorkingSetSize;
+  ::boost::winapi::DWORD_         ActiveProcessLimit;
+  ::boost::winapi::ULONG_PTR_     Affinity;
+  ::boost::winapi::DWORD_         PriorityClass;
+  ::boost::winapi::DWORD_         SchedulingClass;
 } JOBOBJECT_BASIC_LIMIT_INFORMATION_;
 
 
-typedef struct _JOBOBJECT_BASIC_ACCOUNTING_INFORMATION_ {
-    ::boost::winapi::LARGE_INTEGER_ TotalUserTime;
-    ::boost::winapi::LARGE_INTEGER_ TotalKernelTime;
-    ::boost::winapi::LARGE_INTEGER_ ThisPeriodTotalUserTime;
-    ::boost::winapi::LARGE_INTEGER_ ThisPeriodTotalKernelTime;
-    ::boost::winapi::DWORD_         TotalPageFaultCount;
-    ::boost::winapi::DWORD_         TotalProcesses;
-    ::boost::winapi::DWORD_         ActiveProcesses;
-    ::boost::winapi::DWORD_         TotalTerminatedProcesses;
-} JOBOBJECT_BASIC_ACCOUNTING_INFORMATION_;
-
-typedef struct _IO_COUNTERS_
-{
-    ::boost::winapi::ULONGLONG_ ReadOperationCount;
-    ::boost::winapi::ULONGLONG_ WriteOperationCount;
-    ::boost::winapi::ULONGLONG_ OtherOperationCount;
-    ::boost::winapi::ULONGLONG_ ReadTransferCount;
-    ::boost::winapi::ULONGLONG_ WriteTransferCount;
-    ::boost::winapi::ULONGLONG_ OtherTransferCount;
+typedef struct _IO_COUNTERS_ {
+  ::boost::winapi::ULONGLONG_ ReadOperationCount;
+  ::boost::winapi::ULONGLONG_ WriteOperationCount;
+  ::boost::winapi::ULONGLONG_ OtherOperationCount;
+  ::boost::winapi::ULONGLONG_ ReadTransferCount;
+  ::boost::winapi::ULONGLONG_ WriteTransferCount;
+  ::boost::winapi::ULONGLONG_ OtherTransferCount;
 } IO_COUNTERS_;
 
 
-typedef struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION_
-{
-    JOBOBJECT_BASIC_LIMIT_INFORMATION_ BasicLimitInformation;
-    IO_COUNTERS_ IoInfo;
-    ::boost::winapi::SIZE_T_ ProcessMemoryLimit;
-    ::boost::winapi::SIZE_T_ JobMemoryLimit;
-    ::boost::winapi::SIZE_T_ PeakProcessMemoryUsed;
-    ::boost::winapi::SIZE_T_ PeakJobMemoryUsed;
+typedef struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION_ {
+  JOBOBJECT_BASIC_LIMIT_INFORMATION_ BasicLimitInformation;
+  IO_COUNTERS_                       IoInfo;
+  ::boost::winapi::SIZE_T_   ProcessMemoryLimit;
+  ::boost::winapi::SIZE_T_   JobMemoryLimit;
+  ::boost::winapi::SIZE_T_   PeakProcessMemoryUsed;
+  ::boost::winapi::SIZE_T_   PeakJobMemoryUsed;
 } JOBOBJECT_EXTENDED_LIMIT_INFORMATION_;
 
 
@@ -198,7 +82,7 @@ typedef struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION_
   _Out_opt_ LPDWORD            lpReturnLength
 );
  */
-typedef ::boost::winapi::BOOL_ (BOOST_WINAPI_WINAPI_CC *query_information_job_object_p)(
+typedef ::boost::winapi::BOOL_  ( WINAPI *query_information_job_object_p)(
         ::boost::winapi::HANDLE_,
         JOBOBJECTINFOCLASS_,
         void *,
@@ -206,20 +90,17 @@ typedef ::boost::winapi::BOOL_ (BOOST_WINAPI_WINAPI_CC *query_information_job_ob
         ::boost::winapi::DWORD_ *);
 
 
-inline ::boost::winapi::BOOL_ query_information_job_object(
+inline ::boost::winapi::BOOL_ WINAPI query_information_job_object(
         ::boost::winapi::HANDLE_ hJob,
         JOBOBJECTINFOCLASS_ JobObjectInfoClass,
-        void *lpJobObjectInfo,
+        void * lpJobObjectInfo,
         ::boost::winapi::DWORD_ cbJobObjectInfoLength,
         ::boost::winapi::DWORD_ *lpReturnLength)
 {
-    static ::boost::winapi::HMODULE_ h = ::boost::winapi::get_module_handle(
-            L"Kernel32.dll");
-    static query_information_job_object_p f = reinterpret_cast<query_information_job_object_p>(::boost::winapi::get_proc_address(
-            h, "QueryInformationJobObject"));
+    static ::boost::winapi::HMODULE_ h = ::boost::winapi::get_module_handle(L"Kernel32.dll");
+    static query_information_job_object_p f = reinterpret_cast<query_information_job_object_p>(::boost::winapi::get_proc_address(h, "QueryInformationJobObject"));
 
-    return (*f)(hJob, JobObjectInfoClass, lpJobObjectInfo,
-                cbJobObjectInfoLength, lpReturnLength);
+    return (*f)(hJob, JobObjectInfoClass, lpJobObjectInfo, cbJobObjectInfoLength, lpReturnLength);
 }
 
 /*BOOL WINAPI SetInformationJobObject(
@@ -229,7 +110,7 @@ inline ::boost::winapi::BOOL_ query_information_job_object(
   _In_ DWORD              cbJobObjectInfoLength
 );*/
 
-typedef ::boost::winapi::BOOL_ (BOOST_WINAPI_WINAPI_CC *set_information_job_object_p)(
+typedef ::boost::winapi::BOOL_  ( WINAPI *set_information_job_object_p)(
         ::boost::winapi::HANDLE_,
         JOBOBJECTINFOCLASS_,
         void *,
@@ -237,25 +118,22 @@ typedef ::boost::winapi::BOOL_ (BOOST_WINAPI_WINAPI_CC *set_information_job_obje
 
 }
 
-inline ::boost::winapi::BOOL_ set_information_job_object(
+inline ::boost::winapi::BOOL_ WINAPI set_information_job_object(
         ::boost::winapi::HANDLE_ hJob,
         JOBOBJECTINFOCLASS_ JobObjectInfoClass,
-        void *lpJobObjectInfo,
+        void * lpJobObjectInfo,
         ::boost::winapi::DWORD_ cbJobObjectInfoLength)
 {
-    static ::boost::winapi::HMODULE_ h = ::boost::winapi::get_module_handle(
-            L"Kernel32.dll");
-    static set_information_job_object_p f = reinterpret_cast<set_information_job_object_p>(::boost::winapi::get_proc_address(
-            h, "SetInformationJobObject"));
+    static ::boost::winapi::HMODULE_ h = ::boost::winapi::get_module_handle(L"Kernel32.dll");
+    static set_information_job_object_p f = reinterpret_cast<set_information_job_object_p>(::boost::winapi::get_proc_address(h, "SetInformationJobObject"));
 
-    return (*f)(hJob, JobObjectInfoClass, lpJobObjectInfo,
-                cbJobObjectInfoLength);
+    return (*f)(hJob, JobObjectInfoClass, lpJobObjectInfo, cbJobObjectInfoLength);
 }
 
-#endif
-
 constexpr static ::boost::winapi::DWORD_ JOB_OBJECT_LIMIT_BREAKAWAY_OK_ = 0x00000800;
 
 }}}}}
 
+
+
 #endif /* BOOST_PROCESS_DETAIL_WINDOWS_JOB_WORKAROUND_HPP_ */

include/boost/process/detail/windows/search_path.hpp

@@ -55,9 +55,9 @@ inline boost::filesystem::path search_path(
     for (auto & ext : extensions)
         boost::to_lower(ext);
 
-    for (const boost::filesystem::path & pp_ : path)
+    for (const boost::filesystem::path & pp : path)
     {
-        auto p = pp_ / filename;
+        auto p = pp / filename;
         for (boost::filesystem::path ext : extensions)
         {
             boost::filesystem::path pp = p;

include/boost/process/detail/windows/show_window.hpp

@@ -34,7 +34,7 @@ struct create_no_window_ : public ::boost::process::detail::handler_base
     template <class Executor>
     void on_setup(Executor &exec) const
     {
-        exec.creation_flags |= ::boost::winapi::CREATE_NO_WINDOW_;
+        exec.creation_flags |= ::boost::detail::winapi::CREATE_NO_WINDOW_;
     }
 };
 

include/boost/process/detail/windows/wait_group.hpp

@@ -7,7 +7,6 @@
 #define BOOST_PROCESS_DETAIL_WINDOWS_WAIT_GROUP_HPP_
 
 #include <boost/process/detail/config.hpp>
-#include <boost/process/detail/windows/group_handle.hpp>
 #include <boost/winapi/jobs.hpp>
 #include <boost/winapi/wait.hpp>
 #include <chrono>
@@ -16,61 +15,11 @@ namespace boost { namespace process { namespace detail { namespace windows {
 
 struct group_handle;
 
-
-inline bool wait_impl(const group_handle & p, std::error_code & ec, int wait_time)
-{
-    ::boost::winapi::DWORD_ completion_code;
-    ::boost::winapi::ULONG_PTR_ completion_key;
-    ::boost::winapi::LPOVERLAPPED_ overlapped;
-
-    auto start_time = std::chrono::system_clock::now();
-
-    while (workaround::get_queued_completion_status(
-                                       p._io_port, &completion_code,
-                                       &completion_key, &overlapped, wait_time))
-    {
-        if (reinterpret_cast<::boost::winapi::HANDLE_>(completion_key) == p._job_object &&
-             completion_code == workaround::JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO_)
-        {
-
-            //double check, could be a different handle from a child
-            workaround::JOBOBJECT_BASIC_ACCOUNTING_INFORMATION_ info;
-            if (!workaround::query_information_job_object(
-                    p._job_object,
-                    workaround::JobObjectBasicAccountingInformation_,
-                    static_cast<void *>(&info),
-                    sizeof(info), nullptr))
-            {
-                ec = get_last_error();
-                return false;
-            }
-            else if (info.ActiveProcesses == 0)
-                return false; //correct, nothing left.
-        }
-        //reduce the remaining wait time -> in case interrupted by something else
-        if (wait_time != ::boost::winapi::infinite)
-        {
-            auto now = std::chrono::system_clock::now();
-            auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
-            wait_time -= diff.count();
-            start_time = now;
-            if (wait_time <= 0)
-                return true; //timeout with other source
-        }
-
-    }
-
-    auto ec_ = get_last_error();
-    if (ec_.value() == ::boost::winapi::wait_timeout)
-        return true; //timeout
-
-    ec = ec_;
-    return false;
-}
-
 inline void wait(const group_handle &p, std::error_code &ec)
 {
-    wait_impl(p, ec, ::boost::winapi::infinite);
+    if (::boost::winapi::WaitForSingleObject(p.handle(),
+        ::boost::winapi::infinite) == ::boost::winapi::wait_failed)
+            ec = get_last_error();
 }
 
 inline void wait(const group_handle &p)
@@ -90,8 +39,16 @@ inline bool wait_until(
             std::chrono::duration_cast<std::chrono::milliseconds>(
                     timeout_time - Clock::now());
 
-    auto timeout = wait_impl(p, ec, ms.count());
-    return !ec && !timeout;
+    ::boost::winapi::DWORD_ wait_code;
+    wait_code = ::boost::winapi::WaitForSingleObject(p.handle(), ms.count());
+
+    if (wait_code == ::boost::winapi::wait_failed)
+        ec = get_last_error();
+
+    else if (wait_code == ::boost::winapi::wait_timeout)
+        return false; //
+
+    return true;
 }
 
 template< class Clock, class Duration >
@@ -111,9 +68,7 @@ inline bool wait_for(
         const std::chrono::duration<Rep, Period>& rel_time,
         std::error_code &ec)
 {
-    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(rel_time);
-    auto timeout = wait_impl(p, ec, ms.count());
-    return !ec && !timeout;
+    return wait_until(p, std::chrono::steady_clock::now() + rel_time, ec);
 }
 
 template< class Rep, class Period >

include/boost/process/environment.hpp

@@ -94,8 +94,8 @@ struct entry : const_entry<Char, Environment>
     explicit entry(string_type&& name, pointer data, environment_t & env) :
         father(std::move(name), data, env) {}
 
-    explicit entry(string_type &&name, environment_t & env_) :
-        father(std::move(name), env_) {}
+    explicit entry(string_type &&name, environment_t & env) :
+        father(std::move(name), env) {}
 
     entry(const entry&) = default;
     entry& operator=(const entry&) = default;

include/boost/process/exe.hpp

@@ -26,28 +26,10 @@ namespace boost {
 </programlisting>
 \endxmlonly
  */
-namespace boost {
-namespace filesystem { class path; }
-
-namespace process {
-
-namespace detail {
+namespace boost { namespace process { namespace detail {
 
 struct exe_
 {
-    template<typename = void>
-    inline exe_setter_<typename boost::filesystem::path::value_type> operator()(const boost::filesystem::path & pth) const
-    {
-        return exe_setter_<typename boost::filesystem::path::value_type>(pth.native());
-    }
-
-    template<typename = void>
-    inline exe_setter_<typename boost::filesystem::path::value_type> operator=(const boost::filesystem::path & pth) const
-    {
-        return exe_setter_<typename boost::filesystem::path::value_type>(pth.native());
-    }
-
-
     template<typename Char>
     inline exe_setter_<Char> operator()(const Char *s) const
     {

include/boost/process/system.hpp

@@ -85,8 +85,6 @@ inline int system_impl(
         return -1;
 
     ios.run();
-    if (c.running())
-        c.wait();
     return c.exit_code();
 }
 

test/Jamfile.jam

@@ -59,6 +59,7 @@ test-suite bare :
     [ compile no_ansi_apps.cpp ]
     [ compile-fail spawn_fail.cpp        ]
     [ compile-fail async_system_fail.cpp ]
+    [ compile asio_no_deprecated.cpp ]
     ;
 
 test-suite with-valgrind :
@@ -81,9 +82,7 @@ test-suite with-valgrind :
     [ run exit_code.cpp program_options system filesystem     : : sparring_partner ]
     [ run extensions.cpp system filesystem                    : : sparring_partner ]
     [ run env.cpp     program_options system filesystem       : : sparring_partner ]
-    [ run group.cpp     system thread filesystem              : : sub_launch ]
-    [ run group.cpp          system thread filesystem         : : sub_launch : <build>no <target-os>windows:<build>yes <define>BOOST_USE_WINDOWS_H=1 : group-windows-h ]
-    [ run group_wait.cpp     system thread filesystem         : : sparring_partner ]
+    [ run group.cpp     system thread filesystem              : : sub_launch       ]
     [ run run_exe.cpp filesystem                              : : sparring_partner ]
     [ run run_exe_path.cpp filesystem                         : : sparring_partner ]
     [ run search_path.cpp filesystem system                   : : : <target-os>windows:<source>shell32 ]

test/asio_no_deprecated.cpp

@@ -0,0 +1,13 @@
+//
+// Created by kleme on 26.02.2018.
+//
+
+#define BOOST_ASIO_NO_DEPRECATED 1
+#include <boost/process.hpp>
+int main() {}
+
+#if defined(BOOST_POSIX_API)
+#include <boost/process/posix.hpp>
+#elif
+#include <boost/process/windows.hpp>
+#endif

test/group.cpp

@@ -28,6 +28,14 @@
 #include <istream>
 #include <iostream>
 #include <cstdlib>
+#if defined(BOOST_WINDOWS_API)
+#   include <windows.h>
+typedef boost::asio::windows::stream_handle pipe_end;
+#elif defined(BOOST_POSIX_API)
+#   include <sys/wait.h>
+#   include <unistd.h>
+typedef boost::asio::posix::stream_descriptor pipe_end;
+#endif
 
 namespace bp = boost::process;
 

test/group_wait.cpp

@@ -1,109 +0,0 @@
-// Copyright (c) 2006, 2007 Julio M. Merino Vidal
-// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
-// Copyright (c) 2009 Boris Schaeling
-// Copyright (c) 2010 Felipe Tanus, Boris Schaeling
-// Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
-//
-// 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)
-
-#define BOOST_TEST_MAIN
-#define BOOST_TEST_IGNORE_SIGCHLD
-#include <boost/test/included/unit_test.hpp>
-
-#include <boost/system/error_code.hpp>
-
-#include <boost/asio.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-
-#include <boost/process/error.hpp>
-#include <boost/process/io.hpp>
-#include <boost/process/args.hpp>
-#include <boost/process/child.hpp>
-#include <boost/process/group.hpp>
-#include <system_error>
-
-#include <string>
-#include <thread>
-#include <istream>
-#include <iostream>
-#include <cstdlib>
-
-namespace bp = boost::process;
-
-BOOST_AUTO_TEST_CASE(wait_group_test, *boost::unit_test::timeout(5))
-{
-    using boost::unit_test::framework::master_test_suite;
-
-    std::error_code ec;
-    bp::group g;
-
-
-    bp::child c1(
-            master_test_suite().argv[1],
-            "--wait", "1",
-            g,
-            ec
-    );
-
-    bp::child c2(
-            master_test_suite().argv[1],
-            "--wait", "1",
-            g,
-            ec
-    );
-
-    BOOST_CHECK(c1.running());
-    BOOST_CHECK(c2.running());
-
-    BOOST_REQUIRE(!ec);
-    BOOST_REQUIRE(c1.in_group());
-    BOOST_REQUIRE(c2.in_group());
-
-    g.wait();
-
-    BOOST_CHECK(!c1.running());
-    BOOST_CHECK(!c2.running());
-}
-
-
-BOOST_AUTO_TEST_CASE(wait_group_test_timeout, *boost::unit_test::timeout(15))
-{
-    using boost::unit_test::framework::master_test_suite;
-
-    std::error_code ec;
-    bp::group g;
-
-
-    bp::child c1(
-            master_test_suite().argv[1],
-            "--wait", "1",
-            g,
-            ec
-    );
-
-    bp::child c2(
-            master_test_suite().argv[1],
-            "--wait", "3",
-            g,
-            ec
-    );
-
-    BOOST_CHECK(c1.running());
-    BOOST_CHECK(c2.running());
-
-    BOOST_REQUIRE(!ec);
-    BOOST_REQUIRE(c1.in_group());
-    BOOST_REQUIRE(c2.in_group());
-
-    BOOST_CHECK(!g.wait_for(std::chrono::seconds(2), ec));
-
-    BOOST_CHECK_MESSAGE(!ec, std::to_string(ec.value()) + " == " + ec.message());
-    BOOST_CHECK(!c1.running());
-    BOOST_CHECK(c2.running());
-
-    BOOST_CHECK(g.wait_for(std::chrono::seconds(5), ec));
-    BOOST_CHECK_MESSAGE(!ec, std::to_string(ec.value()) + " == " + ec.message());
-    BOOST_CHECK(!c1.running());
-    BOOST_CHECK(!c2.running());
-}

test/system_test1.cpp

@@ -67,15 +67,15 @@ BOOST_AUTO_TEST_CASE(implicit_async_io, *boost::unit_test::timeout(2))
 
     std::future<std::string> fut;
     std::error_code ec;
-    int res = bp::system(
+    bp::system(
         master_test_suite().argv[1],
         "test", "--echo-stdout", "abc",
         bp::std_out > fut,
         ec
     );
     BOOST_REQUIRE(!ec);
+
     BOOST_REQUIRE(fut.valid());
-    BOOST_CHECK_EQUAL(res, 0);
     BOOST_CHECK(boost::starts_with(
             fut.get(), "abc"));
 }