fixes the exit-code error on osx builds.

Closes #200.

.github/workflows/ci.yml

@@ -141,6 +141,43 @@ jobs:
           cd ../boost-root
           ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
 
+  alpine-linux:
+    runs-on: ubuntu-latest
+    container:
+      image: alpine:3.20.1
+    steps:
+      - name: Install packages
+        run: apk add g++ git python3 linux-headers
+
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python3 tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          ./b2 -j3 libs/$LIBRARY/test toolset=gcc cxxstd=23 variant=debug,release
+
   windows:
     strategy:
       fail-fast: false

CMakeLists.txt

@@ -57,7 +57,7 @@ else()
 endif()
 
 if (WIN32)
-  target_link_libraries(boost_process PUBLIC ntdll shell32 Advapi32 user32)
+  target_link_libraries(boost_process PUBLIC ntdll shell32 advapi32 user32)
 endif()
 
 if(BUILD_SHARED_LIBS)

build.jam

@@ -0,0 +1,47 @@
+# Copyright René Ferdinand Rivera Morell 2024
+# 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)
+
+require-b2 5.2 ;
+
+import feature : feature ;
+
+feature boost.process.fs : boost std : optional propagated ;
+feature boost.process.disable-close-range : on off : optional ;
+
+constant boost_dependencies :
+    /boost/algorithm//boost_algorithm
+    /boost/asio//boost_asio
+    /boost/assert//boost_assert
+    /boost/config//boost_config
+    /boost/core//boost_core
+    /boost/fusion//boost_fusion
+    /boost/io//boost_io
+    /boost/iterator//boost_iterator
+    /boost/move//boost_move
+    /boost/optional//boost_optional
+    /boost/system//boost_system
+    /boost/throw_exception//boost_throw_exception
+    /boost/tokenizer//boost_tokenizer
+    /boost/type_index//boost_type_index
+    /boost/type_traits//boost_type_traits
+    /boost/utility//boost_utility
+    /boost/winapi//boost_winapi ;
+
+project /boost/process
+    : common-requirements
+        <include>include
+    : default-build
+        <boost.process.fs>boost
+    ;
+
+explicit
+    [ alias boost_process : build//boost_process ]
+    [ alias all : boost_process example example/v2 test ]
+    ;
+
+call-if : boost-library process
+    : install boost_process
+    ;
+

build/Jamfile

@@ -5,7 +5,8 @@
 
 import os ;
 import feature ;
-import ../../config/checks/config : requires ;
+import-search /boost/config/checks ;
+import config : requires ;
 
 project : requirements
   <define>BOOST_ASIO_NO_DEPRECATED
@@ -15,11 +16,11 @@ project : requirements
   <target-os>windows:<define>WIN32_LEAN_AND_MEAN
   <target-os>linux:<linkflags>-lpthread
   : source-location ../src
+  : common-requirements
+    <library>$(boost_dependencies)
+    <boost.process.fs>std:<define>BOOST_PROCESS_USE_STD_FS=1
 ;
 
-feature.feature boost.process.fs : boost std : propagated composite ;
-feature.compose <boost.process.fs>std : <define>BOOST_PROCESS_USE_STD_FS=1 ;
-
 alias process_sources
    : detail/environment_posix.cpp
      detail/environment_win.cpp
@@ -40,26 +41,33 @@ alias process_sources
      shell.cpp
    ;
 
-if [ os.name ] = NT
-{
-  lib shell32 ;
-  lib Advapi32 ;
-  lib Ntdll ;
-  lib user32 ;
-}
+lib shell32 ;
+lib advapi32 ;
+lib ntdll ;
+lib user32 ;
+lib ws2_32 ;
+
+lib kvm ;
+lib procstat ;
 
 lib boost_process
    : process_sources
    : requirements <define>BOOST_PROCESS_SOURCE=1
      <link>shared:<define>BOOST_PROCESS_DYN_LINK=1
-     <boost.process.fs>boost:<library>/boost//filesystem
+     <boost.process.fs>boost:<library>/boost/filesystem//boost_filesystem
+     <boost.process.disable-close-range>on:<define>BOOST_PROCESS_V2_POSIX_FORCE_DISABLE_CLOSE_RANGE=1
      <target-os>windows:<library>shell32
      <target-os>windows:<library>user32
-     <target-os>windows:<library>Ntdll
-     <target-os>windows:<library>Advapi32
+     <target-os>windows:<library>ntdll
+     <target-os>windows:<library>advapi32
+     <target-os>windows:<library>ws2_32
+     <target-os>bsd:<library>kvm
+     <target-os>freebsd:<library>kvm
+     <target-os>freebsd:<library>procstat
+     <target-os>netbsd:<library>kvm
+     <target-os>openbsd:<library>kvm
+     <target-os>solaris:<library>kvm
    : usage-requirements
      <link>shared:<define>BOOST_PROCESS_DYN_LINK=1
-     <boost.process.fs>boost:<library>/boost//filesystem
+     <boost.process.fs>boost:<library>/boost/filesystem//boost_filesystem
   ;
-
-boost-install boost_process ;

doc/Jamfile.jam

@@ -19,12 +19,12 @@ install images_glob : $(images) : <location>$(BOOST_ROOT)/doc/html/boost_process
 import type ;
 type.register XMLPROCESSWORKAROUND : : XML ;
 import generators ;
-generators.register-standard common.copy : XML : XMLPROCESSWORKAROUND ; 
+generators.register-standard common.copy : XML : XMLPROCESSWORKAROUND ;
 
 xmlprocessworkaround posix_pseudocode   : v1/posix_pseudocode.xml   ;
 xmlprocessworkaround windows_pseudocode : v1/windows_pseudocode.xml ;
 
-path-constant INCLUDES : ../../.. ;
+path-constant INCLUDES : ../include ;
 
 doxygen reference_v1
 :
@@ -63,11 +63,10 @@ doxygen reference_v2
     \"BOOST_PROCESS_V2_END_NAMESPACE= } } }\" \\
     BOOST_PROCESS_V2_NAMESPACE=boost::process::v2 \\
     BOOST_PROCESS_V2_DECL \\
-    BOOST_PROCESS_V2_SOURCE \\
     BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(x,y)=deduced \\
     BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(X)=Token \\
     BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(E)=DEFAULT_TYPE \\
-    BOOST_ASIO_DEFAULT_COMPLETION_TOKEN=DEFAULT \\ 
+    BOOST_ASIO_DEFAULT_COMPLETION_TOKEN=DEFAULT \\
     BOOST_CONSTEXPR=constexpr \\
     BOOST_CXX14_CONSTEXPR=constexpr \\
     BOOST_PROCESS_V2_INLINE= \\
@@ -99,7 +98,7 @@ boostbook standalone
 ###############################################################################
 alias boostdoc
     : standalone/<format>docbook
-    : 
+    :
     : <dependency>images_glob
     : ;
 explicit boostdoc ;

doc/process.qbk

@@ -11,7 +11,7 @@
     ]
 ]
 
-[note Process v1 will be deprecated in the future. Use v2 for new projects.]
+[note Process v1 will be deprecated in the next release (1.88). Use v2 for new projects.]
 
 [include v1.qbk]
 [include v2.qbk]

doc/v1.qbk

@@ -6,6 +6,6 @@
 [include v1/design.qbk]
 [include v1/extend.qbk]
 [include v1/faq.qbk]
-[xinclude reference_v2.xml]
+[xinclude reference_v1.xml]
 
 [endsect]

doc/v2/introduction.qbk

@@ -73,14 +73,6 @@ Instead of using ascii-APIs on windows, process V2 just assumes UTF-8 everywhere
 
 [endsect]
 
-[section:src Separate compilation]
-
-Boost.process v2 supports separate compilation similar to other boost libraries. 
-It can be achieved by defining `BOOST_PROCESS_V2_SEPARATE_COMPILATION` and including 
-`<process/v2/src.hpp>` in a single compile unit.
-
-[endsect]
-
 [section:limit_fd Fd safe by default]
 
 While not a problem on windows (since HANDLEs get manually enabled for inheritance),

example/Jamfile.jam

@@ -8,7 +8,7 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 project : requirements
-  <include>../../..
+  <library>/boost/process//boost_process
   <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
   <target-os>windows:<define>WIN32_LEAN_AND_MEAN
 ;

example/v2/Jamfile.jam

@@ -4,14 +4,12 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 project : requirements
-  <include>../../..
   <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
   <target-os>windows:<define>WIN32_LEAN_AND_MEAN
+  <link>static
 ;
 
 import testing ;
 
-alias filesystem   : /boost//filesystem : <link>static ;
-
-exe intro : intro.cpp filesystem ;
-exe intro_popen : intro_popen.cpp filesystem ;
+exe intro : intro.cpp ;
+exe intro_popen : intro_popen.cpp : <boost.process.fs>boost ;

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

@@ -140,10 +140,7 @@ struct limit_handles_ : handler_base_ext
                     auto itr = std::find(all_handles.begin(), all_handles .end(), handle);
                     ::boost::winapi::DWORD_ flags = 0u;
                     if (itr != all_handles.end())
-                        *itr = ::boost::winapi::INVALID_HANDLE_VALUE_;
-                    else if ((::boost::winapi::GetHandleInformation(*itr, &flags) != 0)
-                            &&((flags & ::boost::winapi::HANDLE_FLAG_INHERIT_) == 0)) //it is NOT inherited anyhow, so ignore too
-                        *itr = ::boost::winapi::INVALID_HANDLE_VALUE_;
+                        *itr = ::boost::winapi::INVALID_HANDLE_VALUE_; // the handle is used mark it as invalid, so it doesn't get reset
                 });
 
         auto part_itr = std::partition(all_handles.begin(), all_handles.end(),

include/boost/process/v1/pipe.hpp

@@ -257,7 +257,16 @@ struct basic_pipebuf : std::basic_streambuf<CharT, Traits>
     {
         if (!is_open())
             return nullptr;
-        overflow(Traits::eof());
+        try {
+          overflow(Traits::eof());
+          _pipe.close();
+          return this;
+        }
+        catch(...)
+        {
+          _pipe.close();
+          throw ;
+        }
         return this;
     }
 private:

include/boost/process/v2/bind_launcher.hpp

@@ -71,7 +71,7 @@ struct bound_launcher
     template<typename ExecutionContext, typename Args, typename ... Inits>
     auto operator()(ExecutionContext & context,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits) -> basic_process<typename ExecutionContext::executor_type>
@@ -88,7 +88,7 @@ struct bound_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -103,8 +103,8 @@ struct bound_launcher
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -120,8 +120,8 @@ struct bound_launcher
     auto operator()(Executor exec,
                     error_code & ec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -138,7 +138,7 @@ struct bound_launcher
     auto invoke(detail::index_sequence<Idx...>, 
                 ExecutionContext & context,
                 const typename std::enable_if<std::is_convertible<
-                        ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                        ExecutionContext&, net::execution_context&>::value,
                         filesystem::path >::type & executable,
                 Args && args,
                 Inits && ... inits) -> basic_process<typename ExecutionContext::executor_type>
@@ -156,7 +156,7 @@ struct bound_launcher
                 ExecutionContext & context,
                 error_code & ec,
                 const typename std::enable_if<std::is_convertible<
-                        ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                        ExecutionContext&, net::execution_context&>::value,
                         filesystem::path >::type & executable,
                 Args && args,
                 Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -172,8 +172,8 @@ struct bound_launcher
     auto invoke(detail::index_sequence<Idx...>,
                 Executor exec,
                 const typename std::enable_if<
-                        BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                        BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                        net::execution::is_executor<Executor>::value ||
+                        net::is_executor<Executor>::value,
                         filesystem::path >::type & executable,
                 Args && args,
                 Inits && ... inits ) -> basic_process<Executor>
@@ -190,8 +190,8 @@ struct bound_launcher
                 Executor exec,
                 error_code & ec,
                 const typename std::enable_if<
-                        BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                        BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                        net::execution::is_executor<Executor>::value ||
+                        net::is_executor<Executor>::value,
                         filesystem::path >::type & executable,
                 Args && args,
                 Inits && ... inits ) -> basic_process<Executor>

include/boost/process/v2/detail/config.hpp

@@ -7,12 +7,7 @@
 
 #if defined(BOOST_PROCESS_V2_STANDALONE)
 
-#define BOOST_PROCESS_V2_ASIO_NAMESPACE asio
 #define BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(Sig) ASIO_COMPLETION_TOKEN_FOR(Sig)
-#define BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(Executor) ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)
-#define BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(Token, Signature) ASIO_INITFN_AUTO_RESULT_TYPE(Token, Signature)
-#define BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN(Executor) ASIO_DEFAULT_COMPLETION_TOKEN(Executor)
-#define BOOST_PROCESS_V2_INITFN_DEDUCED_RESULT_TYPE(x,y,z) ASIO_INITFN_DEDUCED_RESULT_TYPE(x,y,z)
 
 #include <asio/detail/config.hpp>
 #include <system_error>
@@ -24,10 +19,6 @@
 #if defined(ASIO_WINDOWS)
 #define BOOST_PROCESS_V2_WINDOWS 1
 
-// Windows: suppress definition of "min" and "max" macros.
-#if !defined(NOMINMAX)
-# define NOMINMAX 1
-#endif
 #endif
 
 #if defined(ASIO_HAS_UNISTD_H)
@@ -38,14 +29,14 @@
 #define BOOST_PROCESS_V2_END_NAMESPACE   }
 #define BOOST_PROCESS_V2_NAMESPACE process_v2
 
+namespace asio {}
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+namespace net = ::asio;
+BOOST_PROCESS_V2_END_NAMESPACE
+
 #else
 
-#define BOOST_PROCESS_V2_ASIO_NAMESPACE boost::asio
 #define BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(Sig) BOOST_ASIO_COMPLETION_TOKEN_FOR(Sig)
-#define BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(Executor) BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)
-#define BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(Token, Signature) BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(Token, Signature)
-#define BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN(Executor) BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor)
-#define BOOST_PROCESS_V2_INITFN_DEDUCED_RESULT_TYPE(x,y,z) BOOST_ASIO_INITFN_DEDUCED_RESULT_TYPE(x,y,z)
 
 #include <boost/config.hpp>
 #include <boost/io/quoted.hpp>
@@ -57,10 +48,6 @@
 #if defined(BOOST_WINDOWS_API)
 #define BOOST_PROCESS_V2_WINDOWS 1
 
-// Windows: suppress definition of "min" and "max" macros.
-#if !defined(NOMINMAX)
-# define NOMINMAX 1
-#endif
 
 #endif
 
@@ -94,6 +81,11 @@
 #define BOOST_PROCESS_V2_END_NAMESPACE  } } }
 #define BOOST_PROCESS_V2_NAMESPACE boost::process::v2
 
+namespace boost { namespace asio {} }
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+namespace net = ::boost::asio;
+BOOST_PROCESS_V2_END_NAMESPACE
+
 #endif
 
 BOOST_PROCESS_V2_BEGIN_NAMESPACE
@@ -108,9 +100,6 @@ namespace filesystem = std::filesystem;
 using std::quoted;
 using std::optional;
 
-#define BOOST_PROCESS_V2_RETURN_EC(ev)                                                                  \
-  return ::BOOST_PROCESS_V2_NAMESPACE::error_code(ev, ::BOOST_PROCESS_V2_NAMESPACE::system_category()); \
-
 #define BOOST_PROCESS_V2_ASSIGN_EC(ec, ...) ec.assign(__VA_ARGS__);
 #define BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)                         \
   ec.assign(::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error());   \
@@ -131,31 +120,29 @@ namespace filesystem = std::filesystem;
 namespace filesystem = boost::filesystem;
 #endif
 
-#define BOOST_PROCESS_V2_RETURN_EC(ev)                                                                     \
-{                                                                                                          \
-  static constexpr auto loc##__LINE__((BOOST_CURRENT_LOCATION));                                           \
-  return ::BOOST_PROCESS_V2_NAMESPACE::error_code(ev, ::BOOST_PROCESS_V2_NAMESPACE::system_category(), &loc##__LINE__);   \
-}
-
 #define BOOST_PROCESS_V2_ASSIGN_EC(ec, ...)                       \
+do                                                                \
 {                                                                 \
   static constexpr auto loc##__LINE__((BOOST_CURRENT_LOCATION));  \
   ec.assign(__VA_ARGS__,  &loc##__LINE__);                        \
-}
+}                                                                 \
+while (false)
 
 #define BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)                                         \
+do                                                                                     \
 {                                                                                      \
   static constexpr auto loc##__LINE__((BOOST_CURRENT_LOCATION));                       \
   ec.assign(::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error(), &loc##__LINE__);   \
-}
+}                                                                                      \
+while (false)
 
 
 #endif
 
 BOOST_PROCESS_V2_END_NAMESPACE
 
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROCESS_V2_DYN_LINK)
-#if defined(BOOST_PROCESS_V2_SOURCE)
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROCESS_DYN_LINK)
+#if defined(BOOST_PROCESS_SOURCE)
 #define BOOST_PROCESS_V2_DECL BOOST_SYMBOL_EXPORT
 #else
 #define BOOST_PROCESS_V2_DECL BOOST_SYMBOL_IMPORT

include/boost/process/v2/detail/environment_posix.hpp

@@ -69,7 +69,12 @@ BOOST_PROCESS_V2_DECL native_iterator next(native_handle_type nh);
 BOOST_PROCESS_V2_DECL native_iterator find_end(native_handle_type nh);
 inline const char_type * dereference(native_iterator iterator) {return *iterator;}
 
-BOOST_PROCESS_V2_DECL bool is_executable(const filesystem::path & pth, error_code & ec);
+BOOST_PROCESS_V2_DECL bool has_x_access(const char * pth);
+
+inline bool is_executable(const filesystem::path & pth, error_code & ec)
+{
+  return filesystem::is_regular_file(pth, ec) && has_x_access(pth.c_str());
+}
 
 }
 

include/boost/process/v2/detail/environment_win.hpp

@@ -203,7 +203,15 @@ struct native_handle_deleter
 inline const char_type * dereference(native_iterator iterator) {return iterator;}
 BOOST_PROCESS_V2_DECL native_iterator next(native_iterator nh);
 BOOST_PROCESS_V2_DECL native_iterator find_end(native_handle_type nh);
-BOOST_PROCESS_V2_DECL bool is_executable(const filesystem::path & pth, error_code & ec);
+
+
+BOOST_PROCESS_V2_DECL bool is_exec_type(const wchar_t * pth);
+
+inline bool is_executable(const filesystem::path & pth, error_code & ec)
+{
+  return filesystem::is_regular_file(pth, ec) && is_exec_type(pth.c_str());
+}
+
 }
 
 }

include/boost/process/v2/detail/process_handle_fd.hpp

@@ -34,7 +34,7 @@ BOOST_PROCESS_V2_BEGIN_NAMESPACE
 namespace detail
 {
 
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 struct basic_process_handle_fd
 {
     using native_handle_type = int;
@@ -56,7 +56,7 @@ struct basic_process_handle_fd
     basic_process_handle_fd(ExecutionContext &context,
                             typename std::enable_if<
                                 std::is_convertible<ExecutionContext &,
-                                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value>::type * = nullptr)
+                                    net::execution_context &>::value>::type * = nullptr)
             : pid_(-1), descriptor_(context)
     {
     }
@@ -275,35 +275,27 @@ struct basic_process_handle_fd
         return pid_ != -1;
     }
 
-    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, native_exit_code_type))
-    WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
-    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
-    {
-        return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
-                async_wait_op_{descriptor_, pid_}, handler, descriptor_);
-    }
-
   private:
     template<typename>
     friend
     struct basic_process_handle_fd;
     pid_type pid_ = -1;
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_stream_descriptor<Executor> descriptor_;
+    net::posix::basic_stream_descriptor<Executor> descriptor_;
 
     struct async_wait_op_
     {
-        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_descriptor<Executor> &descriptor;
+        net::posix::basic_descriptor<Executor> &descriptor;
         pid_type pid_;
 
         template<typename Self>
         void operator()(Self &&self)
         {
+            self.reset_cancellation_state(asio::enable_total_cancellation());
             error_code ec;
             native_exit_code_type exit_code{};
             int wait_res = -1;
             if (pid_ <= 0) // error, complete early
-                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
+                ec = net::error::bad_descriptor;
             else 
             {
                 wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
@@ -314,8 +306,7 @@ struct basic_process_handle_fd
 
             if (!ec && (wait_res == 0))
             {
-                descriptor.async_wait(
-                        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::descriptor_base::wait_read, std::move(self));
+                descriptor.async_wait(net::posix::descriptor_base::wait_read, std::move(self));
                 return;
             }
 
@@ -330,8 +321,7 @@ struct basic_process_handle_fd
                     self.complete(ec, code);
                 }
             };
-            BOOST_PROCESS_V2_ASIO_NAMESPACE::post(descriptor.get_executor(),
-                                                  completer{ec, exit_code, std::move(self)});
+            net::post(descriptor.get_executor(), completer{ec, exit_code, std::move(self)});
 
         }
 
@@ -345,6 +335,18 @@ struct basic_process_handle_fd
             std::move(self).complete(ec, exit_code);
         }
     };
+ public:
+
+    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, native_exit_code_type))
+    WaitHandler = net::default_completion_token_t<executor_type>>
+    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<executor_type>())
+    -> decltype(net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+        async_wait_op_{descriptor_, pid_}, handler, descriptor_))
+    {
+      return net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+          async_wait_op_{descriptor_, pid_}, handler, descriptor_);
+    }
+
 };
 }
 

include/boost/process/v2/detail/process_handle_fd_or_signal.hpp

@@ -37,7 +37,7 @@ BOOST_PROCESS_V2_BEGIN_NAMESPACE
 namespace detail
 {
 
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 struct basic_process_handle_fd_or_signal
 {
     using native_handle_type = int;
@@ -59,7 +59,7 @@ struct basic_process_handle_fd_or_signal
     basic_process_handle_fd_or_signal(ExecutionContext &context,
                                 typename std::enable_if<
                                         std::is_convertible<ExecutionContext &,
-                                                BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                                net::execution_context &>::value
                                 >::type * = nullptr)
             : pid_(-1), descriptor_(context)
     {
@@ -70,7 +70,7 @@ struct basic_process_handle_fd_or_signal
                                       pid_type pid,
                                       typename std::enable_if<
                                           std::is_convertible<ExecutionContext &,
-                                              BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                              net::execution_context &>::value
                                           >::type * = nullptr)
             : pid_(pid), descriptor_(context)
     {
@@ -81,7 +81,7 @@ struct basic_process_handle_fd_or_signal
                                       pid_type pid, native_handle_type process_handle,
                                       typename std::enable_if<
                                           std::is_convertible<ExecutionContext &,
-                                              BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                              net::execution_context &>::value
                                           >::type * = nullptr)
             : pid_(pid), descriptor_(context, process_handle)
     {
@@ -305,37 +305,35 @@ struct basic_process_handle_fd_or_signal
         return pid_ != -1;
     }
 
-    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, int))
-    WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
-    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
-    {
-        return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
-                async_wait_op_{descriptor_, signal_set_, pid_}, handler, descriptor_);
-    }
-
   private:
     template<typename>
     friend
     struct basic_process_handle_fd_or_signal;
     pid_type pid_ = -1;
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_stream_descriptor<Executor> descriptor_;
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> signal_set_{descriptor_.get_executor(), SIGCHLD};
+    net::posix::basic_stream_descriptor<Executor> descriptor_;
+    net::basic_signal_set<Executor> signal_set_{descriptor_.get_executor(), SIGCHLD};
 
     struct async_wait_op_
     {
-        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_descriptor<Executor> &descriptor;
-        BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> &handle;
+        net::posix::basic_descriptor<Executor> &descriptor;
+        net::basic_signal_set<Executor> &handle;
         pid_type pid_;
         bool needs_post = true;
 
         template<typename Self>
-        void operator()(Self &&self, error_code ec = {}, int = 0)
+        void operator()(Self && self)
+        {
+          self.reset_cancellation_state(asio::enable_total_cancellation());
+          (*this)(std::move(self), error_code{});
+        }
+
+        template<typename Self>
+        void operator()(Self &&self, error_code ec, int = 0)
         {
             native_exit_code_type exit_code{};
             int wait_res = -1;
             if (pid_ <= 0) // error, complete early
-                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
+                ec = net::error::bad_descriptor;
             else 
             {
                 wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
@@ -348,7 +346,7 @@ struct basic_process_handle_fd_or_signal
                 needs_post = false;
                 if (descriptor.is_open())
                     descriptor.async_wait(
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::descriptor_base::wait_read, 
+                            net::posix::descriptor_base::wait_read,
                             std::move(self));
                 else
                     handle.async_wait(std::move(self));
@@ -370,12 +368,22 @@ struct basic_process_handle_fd_or_signal
             const auto exec = self.get_executor();
             completer cpl{ec, exit_code, std::move(self)};
             if (needs_post)
-                BOOST_PROCESS_V2_ASIO_NAMESPACE::post(exec, std::move(cpl));
+                net::post(exec, std::move(cpl));
             else
-                BOOST_PROCESS_V2_ASIO_NAMESPACE::dispatch(exec, std::move(cpl));
+                net::dispatch(exec, std::move(cpl));
 
         }
     };
+ public:
+    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, int))
+             WaitHandler = net::default_completion_token_t<executor_type>>
+    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<executor_type>())
+      -> decltype(net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                  async_wait_op_{descriptor_, signal_set_, pid_}, handler, descriptor_))
+    {
+        return net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                async_wait_op_{descriptor_, signal_set_, pid_}, handler, descriptor_);
+    }
 };
 }
 

include/boost/process/v2/detail/process_handle_signal.hpp

@@ -34,7 +34,7 @@ BOOST_PROCESS_V2_BEGIN_NAMESPACE
 namespace detail
 {
 
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 struct basic_process_handle_signal
 {
     struct native_handle_type
@@ -61,7 +61,7 @@ struct basic_process_handle_signal
     basic_process_handle_signal(ExecutionContext &context,
                          typename std::enable_if<
                                  std::is_convertible<ExecutionContext &,
-                                         BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                         net::execution_context &>::value
                          >::type * = nullptr)
             : pid_(-1), signal_set_(context, SIGCHLD)
     {
@@ -87,7 +87,7 @@ struct basic_process_handle_signal
     {
         pid_ = handle.id();
         signal_set_.~basic_signal_set();
-        using ss = BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor>;
+        using ss = net::basic_signal_set<Executor>;
         new (&signal_set_) ss(handle.get_executor(), SIGCHLD);
         handle.pid_ = -1;
         return *this;
@@ -269,29 +269,21 @@ struct basic_process_handle_signal
         return pid_ != -1;
     }
 
-    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, int))
-    WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
-    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
-    {
-        return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
-                async_wait_op_{signal_set_, pid_}, handler, signal_set_);
-    }
-
   private:
     template<typename>
     friend struct basic_process_handle_signal;
     pid_type pid_ = -1;
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> signal_set_;
+    net::basic_signal_set<Executor> signal_set_;
 
     struct async_wait_op_
     {
-        BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> &handle;
+        net::basic_signal_set<Executor> &handle;
         pid_type pid_;
         
         template<typename Self>
         void operator()(Self &&self)
         {
+            self.reset_cancellation_state(asio::enable_total_cancellation());
             handle.async_wait(std::move(self));
             handle.cancel();
             // we cancel so we end up on the signal-sets executor 
@@ -300,16 +292,16 @@ struct basic_process_handle_signal
         template<typename Self>
         void operator()(Self &&self, error_code ec, int sig)
         {
-            if (ec == BOOST_PROCESS_V2_ASIO_NAMESPACE::error::operation_aborted && 
+            if (ec == net::error::operation_aborted &&
                 self.get_cancellation_state().cancelled() 
-                    == BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_type::none)
+                    == net::cancellation_type::none)
                 ec.clear();
 
             native_exit_code_type exit_code = -1;
             int wait_res = -1;
 
             if (pid_ <= 0) // error, complete early
-                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
+                ec = net::error::bad_descriptor;
             else if (!ec)
             {
                 wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
@@ -336,9 +328,19 @@ struct basic_process_handle_signal
             };
 
             const auto exec = self.get_executor();
-            BOOST_PROCESS_V2_ASIO_NAMESPACE::dispatch(exec, completer{ec, exit_code, std::move(self)});
+            net::dispatch(exec, completer{ec, exit_code, std::move(self)});
         }
     };
+ public:
+    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, int))
+             WaitHandler = net::default_completion_token_t<executor_type>>
+    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<executor_type>())
+      -> decltype(net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                    async_wait_op_{signal_set_, pid_}, handler, signal_set_))
+    {
+        return net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                async_wait_op_{signal_set_, pid_}, handler, signal_set_);
+    }
 };
 
 }

include/boost/process/v2/detail/process_handle_windows.hpp

@@ -38,10 +38,10 @@ BOOST_PROCESS_V2_DECL void terminate_(void * handle, error_code & ec, native_exi
 BOOST_PROCESS_V2_DECL void request_exit_(pid_type pid_, error_code & ec);
 BOOST_PROCESS_V2_DECL void check_running_(void* handle, error_code & ec, native_exit_code_type & exit_status);
 
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 struct basic_process_handle_win
 {
-    typedef BOOST_PROCESS_V2_ASIO_NAMESPACE::windows::basic_object_handle<Executor> handle_type;
+    typedef net::windows::basic_object_handle<Executor> handle_type;
     typedef typename handle_type::native_handle_type native_handle_type;
 
     typedef Executor executor_type;
@@ -61,7 +61,7 @@ struct basic_process_handle_win
     basic_process_handle_win(ExecutionContext &context,
                          typename std::enable_if<
                                  std::is_convertible<ExecutionContext &,
-                                         BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                         net::execution_context &>::value
                          >::type = 0)
             : pid_(0), handle_(context)
     {
@@ -266,15 +266,6 @@ struct basic_process_handle_win
         return handle_.is_open();
     }
 
-    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, native_exit_code_type))
-    WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
-    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
-    {
-        return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
-                async_wait_op_{handle_}, handler, handle_
-        );
-    }
     template<typename>
     friend struct basic_process_handle_win;
   private:
@@ -288,6 +279,17 @@ struct basic_process_handle_win
         template<typename Self>
         void operator()(Self &&self)
         {
+
+            self.reset_cancellation_state(asio::enable_total_cancellation());
+            auto sl = self.get_cancellation_state().slot();
+            auto & h = handle;
+            if (sl.is_connected())
+                sl.assign(
+                    [&h](asio::cancellation_type ct)
+                    {
+                      boost::system::error_code ec;
+                      h.cancel(ec);
+                    });
             handle.async_wait(std::move(self));
         }
 
@@ -295,11 +297,25 @@ struct basic_process_handle_win
         void operator()(Self &&self, error_code ec)
         {
             native_exit_code_type exit_code{};
+            if (ec == asio::error::operation_aborted && !self.get_cancellation_state().cancelled())
+              return handle.async_wait(std::move(self));
+
             if (!ec)
                 detail::get_exit_code_(handle.native_handle(), exit_code, ec);
             std::move(self).complete(ec, exit_code);
         }
     };
+ public:
+    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, native_exit_code_type))
+             WaitHandler = net::default_completion_token_t<executor_type>>
+    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<executor_type>())
+        -> decltype(net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                    async_wait_op_{handle_}, handler, handle_))
+    {
+        return net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                async_wait_op_{handle_}, handler, handle_
+        );
+    }
 };
 
 extern template struct basic_process_handle_win<>;

include/boost/process/v2/detail/utf8.hpp

@@ -23,8 +23,7 @@ BOOST_PROCESS_V2_DECL std::size_t convert_to_wide(const  char   * in, std::size_
 
 template<typename CharOut, typename Traits = std::char_traits<CharOut>, 
          typename Allocator = std::allocator<CharOut>, typename CharIn,
-         typename = typename std::enable_if<std::is_same<CharOut, CharIn>::value>::type>
-BOOST_PROCESS_V2_DECL 
+         typename = typename std::enable_if<std::is_same<CharOut, CharIn>::value>::type> 
 std::basic_string<CharOut, Traits, Allocator> conv_string(
     const CharIn * data, std::size_t size, 
     const Allocator allocator = Allocator{})
@@ -35,8 +34,7 @@ std::basic_string<CharOut, Traits, Allocator> conv_string(
 
 template<typename CharOut, typename Traits = std::char_traits<CharOut>, 
          typename Allocator = std::allocator<CharOut>,
-         typename = typename std::enable_if<std::is_same<CharOut, char>::value>::type>
-BOOST_PROCESS_V2_DECL 
+         typename = typename std::enable_if<std::is_same<CharOut, char>::value>::type> 
 std::basic_string<CharOut, Traits, Allocator> conv_string(
     const wchar_t * data, std::size_t size, 
     const Allocator allocator = Allocator{})
@@ -59,8 +57,7 @@ std::basic_string<CharOut, Traits, Allocator> conv_string(
 
 template<typename CharOut, typename Traits = std::char_traits<CharOut>, 
          typename Allocator = std::allocator<CharOut>,
-         typename = typename std::enable_if<std::is_same<CharOut, wchar_t>::value>::type>
-BOOST_PROCESS_V2_DECL 
+         typename = typename std::enable_if<std::is_same<CharOut, wchar_t>::value>::type> 
 std::basic_string<CharOut, Traits, Allocator> conv_string(
     const char * data, std::size_t size, 
     const Allocator allocator = Allocator{})

include/boost/process/v2/environment.hpp

@@ -764,7 +764,7 @@ struct value
     value& operator=( const Source& source )
     {
         value_ = BOOST_PROCESS_V2_NAMESPACE::detail::conv_string<char_type, traits_type>(
-            source.data(), source.size);
+            source.data(), source.size());
         return *this;
     }
 

include/boost/process/v2/execute.hpp

@@ -47,7 +47,7 @@ struct execute_op
 
     struct cancel
     {
-        using cancellation_type = BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_type;
+        using cancellation_type = net::cancellation_type;
         basic_process<Executor> * proc;
         cancel(basic_process<Executor> * proc) : proc(proc) {}
 
@@ -66,15 +66,15 @@ struct execute_op
     template<typename Self>
     void operator()(Self && self)
     {
-        self.reset_cancellation_state(BOOST_PROCESS_V2_ASIO_NAMESPACE::enable_total_cancellation());
-        BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_slot s = self.get_cancellation_state().slot();
+        self.reset_cancellation_state(net::enable_total_cancellation());
+        net::cancellation_slot s = self.get_cancellation_state().slot();
         if (s.is_connected())
             s.emplace<cancel>(proc.get());
 
         auto pro_ = proc.get();
         pro_->async_wait(
-                BOOST_PROCESS_V2_ASIO_NAMESPACE::bind_cancellation_slot(
-                    BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_slot(),
+                net::bind_cancellation_slot(
+                    net::cancellation_slot(),
                     std::move(self)));
     }
 
@@ -101,17 +101,18 @@ struct execute_op
  * It is to note that `async_execute` will us the lowest selected cancellation
  * type. A subprocess might ignore anything not terminal.
  */
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor,
+template<typename Executor = net::any_io_executor,
         BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void (error_code, int))
-            WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
+            WaitHandler = net::default_completion_token_t<Executor>>
 inline
-BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, int))
-async_execute(basic_process<Executor> proc,
-                         WaitHandler && handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
+auto async_execute(basic_process<Executor> proc,
+                         WaitHandler && handler = net::default_completion_token_t<Executor>())
+   -> decltype(net::async_compose<WaitHandler, void(error_code, int)>(
+                  detail::execute_op<Executor>{nullptr}, handler, std::declval<Executor>()))
 {
     std::unique_ptr<basic_process<Executor>> pro_(new basic_process<Executor>(std::move(proc)));
     auto exec = pro_->get_executor();
-    return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, int)>(
+    return net::async_compose<WaitHandler, void(error_code, int)>(
             detail::execute_op<Executor>{std::move(pro_)}, handler, exec);
 }
 

include/boost/process/v2/ext/cmd.hpp

@@ -8,6 +8,7 @@
 
 #include <string>
 #include <vector>
+#include <memory>
 
 #include <boost/process/v2/detail/config.hpp>
 #include <boost/process/v2/detail/throw_error.hpp>
@@ -36,7 +37,7 @@ BOOST_PROCESS_V2_DECL shell cmd(HANDLE handle);
 #endif
 
 template<typename Executor>
-BOOST_PROCESS_V2_DECL shell cmd(basic_process_handle<Executor> & handle, error_code & ec)
+inline shell cmd(basic_process_handle<Executor> & handle, error_code & ec)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
     return cmd(handle.native_handle(), ec);
@@ -46,7 +47,7 @@ BOOST_PROCESS_V2_DECL shell cmd(basic_process_handle<Executor> & handle, error_c
 }
 
 template<typename Executor>
-BOOST_PROCESS_V2_DECL shell cmd(basic_process_handle<Executor> & handle)
+inline shell cmd(basic_process_handle<Executor> & handle)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
     return cmd(handle.native_handle());

include/boost/process/v2/ext/cwd.hpp

@@ -27,7 +27,7 @@ BOOST_PROCESS_V2_DECL filesystem::path cwd(pid_type pid, error_code & ec);
 BOOST_PROCESS_V2_DECL filesystem::path cwd(pid_type pid);
 
 template<typename Executor>
-BOOST_PROCESS_V2_DECL filesystem::path cwd(basic_process_handle<Executor> & handle, error_code & ec)
+inline filesystem::path cwd(basic_process_handle<Executor> & handle, error_code & ec)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
     return cwd(handle.native_handle(), ec);
@@ -37,7 +37,7 @@ BOOST_PROCESS_V2_DECL filesystem::path cwd(basic_process_handle<Executor> & hand
 }
 
 template<typename Executor>
-BOOST_PROCESS_V2_DECL filesystem::path cwd(basic_process_handle<Executor> & handle)
+inline filesystem::path cwd(basic_process_handle<Executor> & handle)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
     return cwd(handle.native_handle());

include/boost/process/v2/ext/env.hpp

@@ -8,6 +8,7 @@
 #define BOOST_PROCESS_V2_ENV_HPP
 #include <string>
 #include <vector>
+#include <memory>
 
 #include <boost/process/v2/detail/config.hpp>
 #include <boost/process/v2/detail/throw_error.hpp>
@@ -26,9 +27,6 @@ namespace ext
 #if defined(BOOST_PROCESS_V2_WINDOWS)
 using native_env_handle_type = wchar_t *;
 using native_env_iterator = wchar_t *;
-#elif defined(__FreeBSD__)
-using native_env_handle_type = char **;
-using native_env_iterator = char **;
 #else
 using native_env_handle_type = char *;
 using native_env_iterator = char *;
@@ -120,7 +118,7 @@ BOOST_PROCESS_V2_DECL env_view env(pid_type pid, error_code & ec);
 BOOST_PROCESS_V2_DECL env_view env(pid_type pid);
 
 template<typename Executor>
-BOOST_PROCESS_V2_DECL env_view env(basic_process_handle<Executor> & handle, error_code & ec)
+inline env_view env(basic_process_handle<Executor> & handle, error_code & ec)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
     return env(handle.native_handle(), ec);
@@ -130,7 +128,7 @@ BOOST_PROCESS_V2_DECL env_view env(basic_process_handle<Executor> & handle, erro
 }
 
 template<typename Executor>
-BOOST_PROCESS_V2_DECL env_view env(basic_process_handle<Executor> & handle)
+inline env_view env(basic_process_handle<Executor> & handle)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
   return env(handle.native_handle());

include/boost/process/v2/pid.hpp

@@ -10,6 +10,7 @@
 #include <boost/process/v2/detail/throw_error.hpp>
 
 #include <vector>
+#include <memory>
 
 BOOST_PROCESS_V2_BEGIN_NAMESPACE
 

include/boost/process/v2/popen.hpp

@@ -34,7 +34,7 @@ BOOST_PROCESS_V2_BEGIN_NAMESPACE
  * 
  * Popen can be used as a stream object in other protocols.
  */ 
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 struct basic_popen : basic_process<Executor>
 {
     /// The executor of the process
@@ -69,7 +69,7 @@ struct basic_popen : basic_process<Executor>
     explicit basic_popen(ExecutionContext & context,
         typename std::enable_if<
             is_convertible<ExecutionContext&,
-                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value, void *>::type = nullptr)
+                    net::execution_context&>::value, void *>::type = nullptr)
         : basic_process<Executor>{context}
     {
     }
@@ -148,7 +148,7 @@ struct basic_popen : basic_process<Executor>
             ExecutionContext & context,
             typename std::enable_if<
                 std::is_convertible<ExecutionContext&,
-                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                    net::execution_context&>::value,
             const filesystem::path&>::type exe,
             std::initializer_list<string_view> args,
             Inits&&... inits)
@@ -169,7 +169,7 @@ struct basic_popen : basic_process<Executor>
             ExecutionContext & context,
             typename std::enable_if<
                 std::is_convertible<ExecutionContext&,
-                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                    net::execution_context&>::value,
             const filesystem::path&>::type exe,
             std::initializer_list<string_view> args,
             Inits&&... inits)
@@ -189,7 +189,7 @@ struct basic_popen : basic_process<Executor>
             ExecutionContext & context,
             typename std::enable_if<
                 std::is_convertible<ExecutionContext&,
-                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                    net::execution_context&>::value,
             const filesystem::path&>::type exe,
             Args&& args, Inits&&... inits)
             : basic_process<Executor>(context)
@@ -209,7 +209,7 @@ struct basic_popen : basic_process<Executor>
             ExecutionContext & context,
             typename std::enable_if<
                 std::is_convertible<ExecutionContext&,
-                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                    net::execution_context&>::value,
             const filesystem::path&>::type exe,
             Args&& args, Inits&&... inits)
             : basic_process<Executor>(context)
@@ -224,9 +224,9 @@ struct basic_popen : basic_process<Executor>
 
 
     /// The type used for stdin on the parent process side.
-    using stdin_type = BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_writable_pipe<Executor>;
+    using stdin_type = net::basic_writable_pipe<Executor>;
     /// The type used for stdout on the parent process side.
-    using stdout_type = BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_readable_pipe<Executor>;
+    using stdout_type = net::basic_readable_pipe<Executor>;
 
     /// Get the stdin pipe.
     stdin_type  & get_stdin()  {return stdin_; }
@@ -336,14 +336,11 @@ struct basic_popen : basic_process<Executor>
      * std::vector.
      */
     template <typename ConstBufferSequence,
-            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-                                                    std::size_t)) WriteToken
-            BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WriteToken,
-                                       void (boost::system::error_code, std::size_t))
-    async_write_some(const ConstBufferSequence& buffers,
-                     BOOST_ASIO_MOVE_ARG(WriteToken) token
-                     BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, std::size_t))
+            WriteToken = net::default_completion_token_t<executor_type>>
+    auto async_write_some(const ConstBufferSequence& buffers,
+                     WriteToken && token = net::default_completion_token_t<executor_type>())
+         -> decltype(std::declval<stdin_type&>().async_write_some(buffers, std::forward<WriteToken>(token)))
     {
         return stdin_.async_write_some(buffers, std::forward<WriteToken>(token));
     }
@@ -451,14 +448,12 @@ struct basic_popen : basic_process<Executor>
      * std::vector.
      */
     template <typename MutableBufferSequence,
-            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-                                                    std::size_t)) ReadToken
-            BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(ReadToken,
-                                       void (boost::system::error_code, std::size_t))
-    async_read_some(const MutableBufferSequence& buffers,
+            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, std::size_t))
+            ReadToken = net::default_completion_token_t<executor_type>>
+    auto async_read_some(const MutableBufferSequence& buffers,
                     BOOST_ASIO_MOVE_ARG(ReadToken) token
-                    BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+                    = net::default_completion_token_t<executor_type>())
+        -> decltype(std::declval<stdout_type&>().async_read_some(buffers, std::forward<ReadToken>(token)))
     {
         return stdout_.async_read_some(buffers, std::forward<ReadToken>(token));
     }

include/boost/process/v2/posix/default_launcher.hpp

@@ -29,7 +29,7 @@
 #include <unistd.h>
 
 
-#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__APPLE__) || defined(__MACH__)
+#if defined(__APPLE__) || defined(__MACH__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun)
 extern "C" { extern char **environ; }
 #endif
 
@@ -305,7 +305,7 @@ struct default_launcher
     template<typename ExecutionContext, typename Args, typename ... Inits>
     auto operator()(ExecutionContext & context,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -324,19 +324,19 @@ struct default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
     {
-        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
     }
 
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -354,8 +354,8 @@ struct default_launcher
     auto operator()(Executor exec,
                     error_code & ec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -365,12 +365,12 @@ struct default_launcher
             pipe_guard pg;
             if (::pipe(pg.p))
             {
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 return basic_process<Executor>{exec};
             }
             if (::fcntl(pg.p[1], F_SETFD, FD_CLOEXEC))
             {
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 return basic_process<Executor>{exec};
             }
             ec = detail::on_setup(*this, executable, argv, inits ...);
@@ -381,23 +381,23 @@ struct default_launcher
             }
             fd_whitelist.push_back(pg.p[1]);
 
-            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
+            auto & ctx = net::query(
+                    exec, net::execution::context);
+            ctx.notify_fork(net::execution_context::fork_prepare);
             pid = ::fork();
             if (pid == -1)
             {
-                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+                ctx.notify_fork(net::execution_context::fork_parent);
                 detail::on_fork_error(*this, executable, argv, ec, inits...);
                 detail::on_error(*this, executable, argv, ec, inits...);
 
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 return basic_process<Executor>{exec};
             }
             else if (pid == 0)
             {
                 ::close(pg.p[0]);
-                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_child);
+                ctx.notify_fork(net::execution_context::fork_child);
                 ec = detail::on_exec_setup(*this, executable, argv, inits...);
                 if (!ec)
                 {
@@ -407,13 +407,13 @@ struct default_launcher
                     ::execve(executable.c_str(), const_cast<char * const *>(argv), const_cast<char * const *>(env));
 
                 ignore_unused(::write(pg.p[1], &errno, sizeof(int)));
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 detail::on_exec_error(*this, executable, argv, ec, inits...);
                 ::exit(EXIT_FAILURE);
                 return basic_process<Executor>{exec};
             }
 
-            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+            ctx.notify_fork(net::execution_context::fork_parent);
             ::close(pg.p[1]);
             pg.p[1] = -1;
             int child_error{0};
@@ -423,12 +423,12 @@ struct default_launcher
                 int err = errno;
                 if ((err != EAGAIN) && (err != EINTR))
                 {
-                    BOOST_PROCESS_V2_ASSIGN_EC(ec, err, system_category())
+                    BOOST_PROCESS_V2_ASSIGN_EC(ec, err, system_category());
                     break;
                 }
             }
             if (count != 0)
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, child_error, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, child_error, system_category());
 
             if (ec)
             {

include/boost/process/v2/posix/fork_and_forget_launcher.hpp

@@ -20,7 +20,7 @@ struct fork_and_forget_launcher : default_launcher
     template<typename ExecutionContext, typename Args, typename ... Inits>
     auto operator()(ExecutionContext & context,
                     const typename std::enable_if<is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -39,19 +39,19 @@ struct fork_and_forget_launcher : default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
     {
-        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
     }
 
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -69,8 +69,8 @@ struct fork_and_forget_launcher : default_launcher
     auto operator()(Executor exec,
                     error_code & ec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -84,22 +84,22 @@ struct fork_and_forget_launcher : default_launcher
                 return basic_process<Executor>(exec);
             }
 
-            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
+            auto & ctx = net::query(
+                    exec, net::execution::context);
+            ctx.notify_fork(net::execution_context::fork_prepare);
             pid = ::fork();
             if (pid == -1)
             {
-                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+                ctx.notify_fork(net::execution_context::fork_parent);
                 detail::on_fork_error(*this, executable, argv, ec, inits...);
                 detail::on_error(*this, executable, argv, ec, inits...);
 
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 return basic_process<Executor>{exec};
             }
             else if (pid == 0)
             {
-                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_child);
+                ctx.notify_fork(net::execution_context::fork_child);
 
                 ec = detail::on_exec_setup(*this, executable, argv, inits...);
                 if (!ec)
@@ -107,12 +107,12 @@ struct fork_and_forget_launcher : default_launcher
                 if (!ec)
                     ::execve(executable.c_str(), const_cast<char * const *>(argv), const_cast<char * const *>(env));
 
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 detail::on_exec_error(*this, executable, argv, ec, inits...);
                 ::exit(EXIT_FAILURE);
                 return basic_process<Executor>{exec};
             }
-            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+            ctx.notify_fork(net::execution_context::fork_parent);
             if (ec)
             {
                 detail::on_error(*this, executable, argv, ec, inits...);

include/boost/process/v2/posix/pdfork_launcher.hpp

@@ -25,7 +25,7 @@ struct pdfork_launcher : default_launcher
     template<typename ExecutionContext, typename Args, typename ... Inits>
     auto operator()(ExecutionContext & context,
                     const typename std::enable_if<is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -44,19 +44,19 @@ struct pdfork_launcher : default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
     {
-        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
     }
 
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -74,8 +74,8 @@ struct pdfork_launcher : default_launcher
     auto operator()(Executor exec,
                     error_code & ec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -85,12 +85,12 @@ struct pdfork_launcher : default_launcher
             pipe_guard pg;
             if (::pipe(pg.p))
             {
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 return basic_process<Executor>{exec};
             }
             if (::fcntl(pg.p[1], F_SETFD, FD_CLOEXEC))
             {
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 return basic_process<Executor>{exec};
             }
             ec = detail::on_setup(*this, executable, argv, inits ...);
@@ -101,22 +101,22 @@ struct pdfork_launcher : default_launcher
             }
             fd_whitelist.push_back(pg.p[1]);
 
-            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
+            auto & ctx = net::query(
+                    exec, net::execution::context);
+            ctx.notify_fork(net::execution_context::fork_prepare);
             pid = ::pdfork(&fd, PD_DAEMON | PD_CLOEXEC);
             if (pid == -1)
             {
-                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+                ctx.notify_fork(net::execution_context::fork_parent);
                 detail::on_fork_error(*this, executable, argv, ec, inits...);
                 detail::on_error(*this, executable, argv, ec, inits...);
 
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 return basic_process<Executor>{exec};
             }
             else if (pid == 0)
             {
-                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_child);
+                ctx.notify_fork(net::execution_context::fork_child);
                 ::close(pg.p[0]);
 
                 ec = detail::on_exec_setup(*this, executable, argv, inits...);
@@ -128,12 +128,12 @@ struct pdfork_launcher : default_launcher
                     ::execve(executable.c_str(), const_cast<char * const *>(argv), const_cast<char * const *>(env));
 
                 default_launcher::ignore_unused(::write(pg.p[1], &errno, sizeof(int)));
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
                 detail::on_exec_error(*this, executable, argv, ec, inits...);
                 ::exit(EXIT_FAILURE);
                 return basic_process<Executor>{exec};
             }
-            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+            ctx.notify_fork(net::execution_context::fork_parent);
             ::close(pg.p[1]);
             pg.p[1] = -1;
             int child_error{0};
@@ -143,12 +143,12 @@ struct pdfork_launcher : default_launcher
                 int err = errno;
                 if ((err != EAGAIN) && (err != EINTR))
                 {
-                    BOOST_PROCESS_V2_ASSIGN_EC(ec, err, system_category())
+                    BOOST_PROCESS_V2_ASSIGN_EC(ec, err, system_category());
                     break;
                 }
             }
             if (count != 0)
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, child_error, system_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, child_error, system_category());
 
             if (ec)
             {

include/boost/process/v2/posix/vfork_launcher.hpp

@@ -22,7 +22,7 @@ struct vfork_launcher :  default_launcher
     template<typename ExecutionContext, typename Args, typename ... Inits>
     auto operator()(ExecutionContext & context,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -41,19 +41,19 @@ struct vfork_launcher :  default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                            ExecutionContext&, net::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
     {
-        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
     }
 
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -71,8 +71,8 @@ struct vfork_launcher :  default_launcher
     auto operator()(Executor exec,
                     error_code & ec,
                     const typename std::enable_if<
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                            net::execution::is_executor<Executor>::value ||
+                            net::is_executor<Executor>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<Executor>
@@ -86,17 +86,17 @@ struct vfork_launcher :  default_launcher
             return basic_process<Executor>(exec);
         }
 
-        auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-        ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
+        auto & ctx = net::query(
+                exec, net::execution::context);
+        ctx.notify_fork(net::execution_context::fork_prepare);
         pid = ::vfork();
         if (pid == -1)
         {
-            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+            ctx.notify_fork(net::execution_context::fork_parent);
             detail::on_fork_error(*this, executable, argv, ec, inits...);
             detail::on_error(*this, executable, argv, ec, inits...);
 
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
             return basic_process<Executor>{exec};
         }
         else if (pid == 0)
@@ -107,12 +107,12 @@ struct vfork_launcher :  default_launcher
             if (!ec)
                 ::execve(executable.c_str(), const_cast<char * const *>(argv), const_cast<char * const *>(env));
 
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, errno, system_category());
             detail::on_exec_error(*this, executable, argv, ec, inits...);
             ::_exit(EXIT_FAILURE);
             return basic_process<Executor>{exec};
         }
-        ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_parent);
+        ctx.notify_fork(net::execution_context::fork_parent);
 
         if (ec)
         {

include/boost/process/v2/process.hpp

@@ -34,7 +34,7 @@ BOOST_PROCESS_V2_BEGIN_NAMESPACE
 /* A `basic_process` object manages a subprocess; it tracks the status and exit-code,
  * and will terminate the process on destruction if `detach` was not called.
 */
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 struct basic_process
 {
   /// The executor of the process
@@ -111,7 +111,7 @@ struct basic_process
       ExecutionContext & context,
       typename std::enable_if<
           std::is_convertible<ExecutionContext&, 
-                              BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                              net::execution_context&>::value,
           const filesystem::path&>::type exe,
       std::initializer_list<string_view> args,
       Inits&&... inits)
@@ -125,7 +125,7 @@ struct basic_process
       ExecutionContext & context,
       typename std::enable_if<
           std::is_convertible<ExecutionContext&, 
-                              BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                              net::execution_context&>::value,
           const filesystem::path&>::type exe,
       Args&& args, Inits&&... inits)
       : basic_process(default_process_launcher()(executor_type(context.get_executor()),
@@ -148,7 +148,7 @@ struct basic_process
   explicit basic_process(ExecutionContext & context, pid_type pid,
                          typename std::enable_if<
                              std::is_convertible<ExecutionContext&,
-                                BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value, void *>::type = nullptr)
+                                net::execution_context&>::value, void *>::type = nullptr)
        : process_handle_(context, pid) {}
 
   /// Attach to an existing process and the internal handle
@@ -156,7 +156,7 @@ struct basic_process
   explicit basic_process(ExecutionContext & context, pid_type pid, native_handle_type native_handle,
                          typename std::enable_if<
                             std::is_convertible<ExecutionContext&, 
-                                BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value, void *>::type = nullptr)
+                                net::execution_context&>::value, void *>::type = nullptr)
       : process_handle_(context.get_executor(), pid, native_handle) {}
 
   /// Create an invalid handle
@@ -164,7 +164,7 @@ struct basic_process
   explicit basic_process(ExecutionContext & context,
                          typename std::enable_if<
                              is_convertible<ExecutionContext&, 
-                                BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value, void *>::type = nullptr)
+                                net::execution_context&>::value, void *>::type = nullptr)
      : process_handle_(context.get_executor()) {}
 
 
@@ -325,15 +325,7 @@ struct basic_process
   /** Note that this might be a process that already exited.*/
   bool is_open() const { return process_handle_.is_open(); }
   
-  /// Asynchronously wait for the process to exit and deliver the native exit-code in the completion handler.
-  template <BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void (error_code, int))
-            WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-  BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, int))
-  async_wait(WaitHandler && handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
-  {
-    return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void (error_code, int)>(
-      async_wait_op_{process_handle_, exit_status_}, handler, process_handle_);
-  }
+
 
 private:
   template<typename Executor1>
@@ -363,7 +355,7 @@ private:
             }
         };
 
-        BOOST_PROCESS_V2_ASIO_NAMESPACE::post(handle.get_executor(),
+        net::post(handle.get_executor(),
                                               completer{static_cast<int>(res), std::move(self)});
       }
       else
@@ -383,6 +375,18 @@ private:
       }
     }
   };
+
+ public:
+  /// Asynchronously wait for the process to exit and deliver the native exit-code in the completion handler.
+  template <BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void (error_code, int))
+  WaitHandler = net::default_completion_token_t<executor_type>>
+  auto async_wait(WaitHandler && handler = net::default_completion_token_t<executor_type>())
+    -> decltype(net::async_compose<WaitHandler, void (error_code, int)>(
+        async_wait_op_{process_handle_, exit_status_}, handler, process_handle_))
+  {
+    return net::async_compose<WaitHandler, void (error_code, int)>(
+        async_wait_op_{process_handle_, exit_status_}, handler, process_handle_);
+  }
 };
 
 /// Process with the default executor.

include/boost/process/v2/process_handle.hpp

@@ -32,7 +32,7 @@ BOOST_PROCESS_V2_BEGIN_NAMESPACE
  * Note that the exit code might be discovered early, during a call to `running`.
  * Thus it can only be discovered that process has exited already.
  */
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 struct basic_process_handle
 {
     /// The native handle of the process. 
@@ -123,28 +123,26 @@ struct basic_process_handle
 
     /// Asynchronously wait for the process to exit and deliver the native exit-code in the completion handler.
     template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, native_exit_code_type))
-             WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-             BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
-    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type));
-
+             WaitHandler = net::default_completion_token_t<executor_type>>
+    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<executor_type>());
 };
 
 
 #else
 #if defined(BOOST_PROCESS_V2_WINDOWS)
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 using basic_process_handle = detail::basic_process_handle_win<Executor>;
 #else
 
 #if defined(BOOST_PROCESS_V2_PIDFD_OPEN)
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 using basic_process_handle = detail::basic_process_handle_fd<Executor>;
 #elif defined(BOOST_PROCESS_V2_PDFORK)
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 using basic_process_handle = detail::basic_process_handle_fd_or_signal<Executor>;
 #else
 
-template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+template<typename Executor = net::any_io_executor>
 using basic_process_handle = detail::basic_process_handle_signal<Executor>;
 
 #endif

include/boost/process/v2/stdio.hpp

@@ -103,7 +103,7 @@ struct process_io_binding
 
 
   template<typename Executor>
-  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_readable_pipe<Executor> & pipe)
+  process_io_binding(net::basic_readable_pipe<Executor> & pipe)
   {
     if (Target == STD_INPUT_HANDLE)
     {
@@ -112,9 +112,9 @@ struct process_io_binding
       return ;
     }
 
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
+    net::detail::native_pipe_handle p[2];
     error_code ec;
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::create_pipe(p, ec);
+    net::detail::create_pipe(p, ec);
     if (ec)
       detail::throw_error(ec, "create_pipe");
       
@@ -124,7 +124,7 @@ struct process_io_binding
 
 
   template<typename Executor>
-  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_writable_pipe<Executor> & pipe)
+  process_io_binding(net::basic_writable_pipe<Executor> & pipe)
   {
     if (Target != STD_INPUT_HANDLE)
     {
@@ -132,9 +132,9 @@ struct process_io_binding
       h = std::unique_ptr<void, handle_closer>{h_, get_flags(h_)};
       return ;
     }
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
+    net::detail::native_pipe_handle p[2];
     error_code ec;
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::create_pipe(p, ec);
+    net::detail::create_pipe(p, ec);
     if (ec)
       detail::throw_error(ec, "create_pipe");
 
@@ -181,7 +181,7 @@ struct process_io_binding
   }
 
   template<typename Executor>
-  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_readable_pipe<Executor> & readable_pipe)
+  process_io_binding(net::basic_readable_pipe<Executor> & readable_pipe)
   {
     if (Target == STDIN_FILENO)
     {
@@ -189,15 +189,15 @@ struct process_io_binding
       return ;
     }
 
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::create_pipe(p, ec);
+    net::detail::native_pipe_handle p[2];
+    net::detail::create_pipe(p, ec);
     if (ec)
       detail::throw_error(ec, "create_pipe");
 
     fd = p[1];
     if (::fcntl(p[0], F_SETFD, FD_CLOEXEC) == -1)
     {
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
       return ;
     }
     fd_needs_closing = true;
@@ -206,7 +206,7 @@ struct process_io_binding
 
 
   template<typename Executor>
-  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_writable_pipe<Executor> & writable_pipe)
+  process_io_binding(net::basic_writable_pipe<Executor> & writable_pipe)
   {
 
     if (Target != STDIN_FILENO)
@@ -214,16 +214,16 @@ struct process_io_binding
       fd = writable_pipe.native_handle();
       return ;
     }
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
+    net::detail::native_pipe_handle p[2];
     error_code ec;
-    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::create_pipe(p, ec);
+    net::detail::create_pipe(p, ec);
     if (ec)
       detail::throw_error(ec, "create_pipe");
 
     fd = p[0];
     if (::fcntl(p[1], F_SETFD, FD_CLOEXEC) == -1)
     {
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
       return ;
     }
     fd_needs_closing = true;

include/boost/process/v2/windows/as_user_launcher.hpp

@@ -28,7 +28,7 @@ struct as_user_launcher : default_launcher
   template<typename ExecutionContext, typename Args, typename ... Inits>
   auto operator()(ExecutionContext & context,
                   const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -47,19 +47,19 @@ struct as_user_launcher : default_launcher
   auto operator()(ExecutionContext & context,
                      error_code & ec,
                      const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
   {
-      return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+      return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
   }
 
   template<typename Executor, typename Args, typename ... Inits>
   auto operator()(Executor exec,
                      const typename std::enable_if<
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                             net::execution::is_executor<Executor>::value ||
+                             net::is_executor<Executor>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<Executor>
@@ -77,8 +77,8 @@ struct as_user_launcher : default_launcher
   auto operator()(Executor exec,
                   error_code & ec,
                   const typename std::enable_if<
-                      BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                      BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                      net::execution::is_executor<Executor>::value ||
+                      net::is_executor<Executor>::value,
                         filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> basic_process<Executor>
@@ -107,7 +107,7 @@ struct as_user_launcher : default_launcher
 
     if (ok == 0)
     {
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
       detail::on_error(*this, executable, command_line, ec, inits...);
 
       if (process_information.hProcess != INVALID_HANDLE_VALUE)
@@ -133,4 +133,4 @@ struct as_user_launcher : default_launcher
 }
 BOOST_PROCESS_V2_END_NAMESPACE
 
-#endif //  BOOST_PROCESS_V2_WINDOWS_AS_USER_LAUNCHER_HPP
+#endif //  BOOST_PROCESS_V2_WINDOWS_AS_USER_LAUNCHER_HPP

include/boost/process/v2/windows/default_launcher.hpp

@@ -236,7 +236,7 @@ struct default_launcher
   template<typename ExecutionContext, typename Args, typename ... Inits>
   auto operator()(ExecutionContext & context,
                   const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> enable_init<typename ExecutionContext::executor_type, Inits...>
@@ -255,7 +255,7 @@ struct default_launcher
   auto operator()(ExecutionContext & context,
                   error_code & ec,
                   const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> enable_init<typename ExecutionContext::executor_type, Inits...>
@@ -266,8 +266,8 @@ struct default_launcher
   template<typename Executor, typename Args, typename ... Inits>
   auto operator()(Executor exec,
                   const typename std::enable_if<
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value 
-                          || BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                             net::execution::is_executor<Executor>::value
+                          || net::is_executor<Executor>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> enable_init<Executor, Inits...>
@@ -285,8 +285,8 @@ struct default_launcher
   auto operator()(Executor exec,
                   error_code & ec,
                   const typename std::enable_if<
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                             net::execution::is_executor<Executor>::value ||
+                             net::is_executor<Executor>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> enable_init<Executor, Inits...>
@@ -314,7 +314,7 @@ struct default_launcher
 
     if (ok == 0)
     {
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
       detail::on_error(*this, executable, command_line, ec, inits...);
 
       if (process_information.hProcess != INVALID_HANDLE_VALUE)

include/boost/process/v2/windows/with_logon_launcher.hpp

@@ -39,7 +39,7 @@ struct with_logon_launcher : default_launcher
   auto operator()(ExecutionContext & context,
                   error_code & ec,
                   const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -51,7 +51,7 @@ struct with_logon_launcher : default_launcher
   template<typename ExecutionContext, typename Args, typename ... Inits>
   auto operator()(ExecutionContext & context,
                      const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -62,8 +62,8 @@ struct with_logon_launcher : default_launcher
   template<typename Executor, typename Args, typename ... Inits>
   auto operator()(Executor exec,
                      const typename std::enable_if<
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                             net::execution::is_executor<Executor>::value ||
+                             net::is_executor<Executor>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<Executor>
@@ -81,8 +81,8 @@ struct with_logon_launcher : default_launcher
   auto operator()(Executor exec,
                      error_code & ec,
                      const typename std::enable_if<
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                             net::execution::is_executor<Executor>::value ||
+                             net::is_executor<Executor>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<Executor>
@@ -111,7 +111,7 @@ struct with_logon_launcher : default_launcher
 
     if (ok == 0)
     {
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
       detail::on_error(*this, executable, command_line, ec, inits...);
 
       if (process_information.hProcess != INVALID_HANDLE_VALUE)

include/boost/process/v2/windows/with_token_launcher.hpp

@@ -29,7 +29,7 @@ struct with_token_launcher : default_launcher
   template<typename ExecutionContext, typename Args, typename ... Inits>
   auto operator()(ExecutionContext & context,
                   const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -48,7 +48,7 @@ struct with_token_launcher : default_launcher
   auto operator()(ExecutionContext & context,
                      error_code & ec,
                      const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
+                             ExecutionContext&, net::execution_context&>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -59,8 +59,8 @@ struct with_token_launcher : default_launcher
   template<typename Executor, typename Args, typename ... Inits>
   auto operator()(Executor exec,
                      const typename std::enable_if<
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                             net::execution::is_executor<Executor>::value ||
+                             net::is_executor<Executor>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<Executor>
@@ -78,8 +78,8 @@ struct with_token_launcher : default_launcher
   auto operator()(Executor exec,
                      error_code & ec,
                      const typename std::enable_if<
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                             BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
+                             net::execution::is_executor<Executor>::value ||
+                             net::is_executor<Executor>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<Executor>
@@ -106,7 +106,7 @@ struct with_token_launcher : default_launcher
 
     if (ok == 0)
     {
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
       detail::on_error(*this, executable, command_line, ec, inits...);
 
       if (process_information.hProcess != INVALID_HANDLE_VALUE)

src/detail/environment_posix.cpp

@@ -30,7 +30,7 @@ basic_cstring_ref<char_type, value_char_traits<char>> get(
     auto res = ::getenv(key.c_str());
     if (res == nullptr)
     {
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOENT, system_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOENT, system_category());
         return {};
     }
     return res;
@@ -41,13 +41,13 @@ void set(basic_cstring_ref<char_type,   key_char_traits<char_type>>   key,
                 error_code & ec)
 {
     if (::setenv(key.c_str(), value.c_str(), true))
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 void unset(basic_cstring_ref<char_type, key_char_traits<char_type>> key, error_code & ec)
 {
     if (::unsetenv(key.c_str()))
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 
@@ -65,9 +65,10 @@ native_iterator find_end(native_handle_type nh)
         nh++;
     return nh;
 }
-bool is_executable(const filesystem::path & p, error_code & ec)
+
+bool has_x_access(const char * pth)
 {
-    return filesystem::is_regular_file(p, ec) && (::access(p.c_str(), X_OK) == 0);
+  return (::access(pth, X_OK) == 0);
 }
 
 }

src/detail/environment_win.cpp

@@ -45,7 +45,7 @@ std::basic_string<char_type, value_char_traits<char_type>> get(
   buf.resize(size);
 
   if (buf.size() == 0)
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 
   return buf;
 }
@@ -55,14 +55,14 @@ void set(basic_cstring_ref<char_type,   key_char_traits<char_type>>   key,
          error_code & ec)
 {
   if (!::SetEnvironmentVariableW(key.c_str(), value.c_str()))
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 void unset(basic_cstring_ref<char_type, key_char_traits<char_type>> key,
            error_code & ec)
 {
   if (!::SetEnvironmentVariableW(key.c_str(), nullptr))
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 
@@ -83,7 +83,7 @@ std::basic_string<char, value_char_traits<char>> get(
   buf.resize(size);
 
   if (buf.size() == 0)
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 
   return buf;
 }
@@ -93,14 +93,14 @@ void set(basic_cstring_ref<char,   key_char_traits<char>>   key,
          error_code & ec)
 {
   if (!::SetEnvironmentVariableA(key.c_str(), value.c_str()))
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 void unset(basic_cstring_ref<char, key_char_traits<char>> key,
            error_code & ec)
 {
   if (!::SetEnvironmentVariableA(key.c_str(), nullptr))
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 
@@ -125,9 +125,9 @@ native_iterator find_end(native_handle_type nh)
   return ++nh;
 }
 
-bool is_executable(const filesystem::path & pth, error_code & ec)
+bool is_exec_type(const wchar_t * pth)
 {
-    return filesystem::is_regular_file(pth, ec) && SHGetFileInfoW(pth.native().c_str(), 0,0,0, SHGFI_EXETYPE);
+    return SHGetFileInfoW(pth, 0,0,0, SHGFI_EXETYPE);
 }
 
 }

src/detail/process_handle_windows.cpp

@@ -35,7 +35,7 @@ void get_exit_code_(
     error_code & ec)
 {
     if (!::GetExitCodeProcess(handle, &exit_code))
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 
@@ -45,7 +45,7 @@ HANDLE open_process_(DWORD pid)
     if (proc == nullptr)
     {
         error_code ec;
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         throw system_error(ec, "open_process()");
     }
 
@@ -67,7 +67,7 @@ bool check_handle_(HANDLE handle, error_code & ec)
 {
     if (handle == INVALID_HANDLE_VALUE)
     {
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_INVALID_HANDLE_STATE, system_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_INVALID_HANDLE_STATE, system_category());
         return false;
     }
     return true;
@@ -77,7 +77,7 @@ bool check_pid_(pid_type pid_, error_code & ec)
 {
     if (pid_ == 0)
     {
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_INVALID_HANDLE_STATE, system_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_INVALID_HANDLE_STATE, system_category());
         return false;
     }
     return true;
@@ -100,7 +100,7 @@ static BOOL CALLBACK enum_window(HWND hwnd, LPARAM param)
     LRESULT res = ::SendMessageW(hwnd, WM_CLOSE, 0, 0);
 
     if (res)
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(data->ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(data->ec);
     return res == 0;
 }
 
@@ -109,25 +109,25 @@ void request_exit_(pid_type pid_, error_code & ec)
     enum_windows_data_t data{ec, pid_};
 
     if (!::EnumWindows(enum_window, reinterpret_cast<LONG_PTR>(&data)))
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 void interrupt_(pid_type pid_, error_code & ec)
 {
     if (!::GenerateConsoleCtrlEvent(CTRL_C_EVENT, pid_))
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 void terminate_(HANDLE handle, error_code & ec, DWORD & exit_status)
 {
     if (!::TerminateProcess(handle, 260))
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 void check_running_(HANDLE handle, error_code & ec, DWORD & exit_status)
 {
     if (!::GetExitCodeProcess(handle, &exit_status))
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 #if !defined(BOOST_PROCESS_V2_DISABLE_UNDOCUMENTED_API)
@@ -136,7 +136,7 @@ void suspend_(HANDLE handle, error_code & ec)
     auto nt_err = NtSuspendProcess(handle);
     ULONG dos_err = RtlNtStatusToDosError(nt_err);
     if (dos_err)
-       BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+       BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 
 void resume_(HANDLE handle, error_code & ec)
@@ -144,17 +144,17 @@ void resume_(HANDLE handle, error_code & ec)
     auto nt_err = NtResumeProcess(handle);
     ULONG dos_err = RtlNtStatusToDosError(nt_err);
     if (dos_err)
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 }
 #else
 void suspend_(HANDLE, error_code & ec)
 {
-    BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_CALL_NOT_IMPLEMENTED, system_category())
+    BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_CALL_NOT_IMPLEMENTED, system_category());
 }
 
 void resume_(HANDLE handle, error_code & ec)
 {
-    BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_CALL_NOT_IMPLEMENTED, system_category())
+    BOOST_PROCESS_V2_ASSIGN_EC(ec, ERROR_CALL_NOT_IMPLEMENTED, system_category());
 }
 #endif
 

src/detail/utf8.cpp

@@ -9,7 +9,7 @@
 #include <boost/process/v2/error.hpp>
 
 #if defined(BOOST_PROCESS_V2_WINDOWS)
-#include <Windows.h>
+#include <windows.h>
 #endif
 
 BOOST_PROCESS_V2_BEGIN_NAMESPACE
@@ -25,13 +25,13 @@ inline void handle_error(error_code & ec)
     switch (err)
     {
     case ERROR_INSUFFICIENT_BUFFER:
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::utf8_category)
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::utf8_category);
         break;
     case ERROR_NO_UNICODE_TRANSLATION:
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::utf8_category)
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::utf8_category);
         break;
     default:
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, err, system_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, err, system_category());
     }
 }
 
@@ -240,7 +240,7 @@ std::size_t convert_to_utf8(const wchar_t * in, std::size_t size,
         if (*from  > max_wchar) {
             from_next = from;
             to_next = to;
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::get_utf8_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::get_utf8_category());
             return 0u;
         }
 
@@ -268,7 +268,7 @@ std::size_t convert_to_utf8(const wchar_t * in, std::size_t size,
         if (to == to_end && i != cont_octet_count) {
             from_next = from;
             to_next = to - (i + 1);
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category());
             return 0u;
         }
         ++from;
@@ -278,7 +278,7 @@ std::size_t convert_to_utf8(const wchar_t * in, std::size_t size,
 
     // Were we done or did we run out of destination space
     if (from != from_end)
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category());
 
     return to_next - out;
 }
@@ -313,7 +313,7 @@ std::size_t convert_to_wide(const  char   * in, std::size_t size,
         if (invalid_leading_octet(*from)) {
             from_next = from;
             to_next = to;
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::get_utf8_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::get_utf8_category());
             return 0u;
         }
 
@@ -337,7 +337,7 @@ std::size_t convert_to_wide(const  char   * in, std::size_t size,
             if (invalid_continuing_octet(*from)) {
                 from_next = from;
                 to_next = to;
-                BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::get_utf8_category())
+                BOOST_PROCESS_V2_ASSIGN_EC(ec, error::invalid_character, error::get_utf8_category());
                 return 0u;
             }
 
@@ -354,7 +354,7 @@ std::size_t convert_to_wide(const  char   * in, std::size_t size,
             // rewind "from" to before the current character translation
             from_next = from - (i + 1);
             to_next = to;
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category());
             return 0u;
         }
         *to++ = ucs_result;
@@ -363,7 +363,7 @@ std::size_t convert_to_wide(const  char   * in, std::size_t size,
     to_next = to;
 
     if (from != from_end)
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error::insufficient_buffer, error::get_utf8_category());
 
     return to_next - out;
 }

src/ext/cmd.cpp

@@ -23,9 +23,12 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <sys/proc_info.h>
-#include <sys/sysctl.h>
-#include <libproc.h>
+#include <TargetConditionals.h>
+#if !TARGET_OS_IOS
+  #include <sys/proc_info.h>
+  #include <sys/sysctl.h>
+  #include <libproc.h>
+#endif
 #endif
 
 #if (defined(__linux__) || defined(__ANDROID__))
@@ -49,6 +52,7 @@
 #endif
 
 #if defined(__sun)
+#include <cstdlib>
 #include <sys/types.h>
 #include <kvm.h>
 #include <sys/param.h>
@@ -156,7 +160,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
 }
     
-#elif (defined(__APPLE__) && defined(__MACH__))
+#elif (defined(__APPLE__) && defined(__MACH__)) && !TARGET_OS_IOS
 
 shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -165,7 +169,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     auto size = sizeof(argmax);
     if (sysctl(mib, 2, &argmax, &size, nullptr, 0) == -1)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
@@ -178,7 +182,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
     if (sysctl(mib, 3, &*procargs.begin(), &size, nullptr, 0) != 0)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
@@ -195,7 +199,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
         auto e = std::find(itr, end, '\0');
         if (e == end && n < argc) // something off
         {
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, EINVAL, system_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, EINVAL, system_category());
             return {};
         }
         argv[n] = &*itr;
@@ -220,7 +224,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
         auto r = ::read(f, &*(procargs.end() - 4096), 4096);
         if (r < 0)
         {
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
             ::close(f);
             return {};
         }
@@ -251,7 +255,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
         auto e = std::find(itr, end, '\0');
         if (e == end && n < argc) // something off
         {
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, EINVAL, system_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, EINVAL, system_category());
             return {};
         }
         argv[n] = &*itr;
@@ -271,6 +275,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -280,17 +285,17 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     };
 
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return {};}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp))) 
     {
         char **cmd = kvm_getargv(kd.get(), proc_info, 0);
         if (cmd)
             return make_cmd_shell_::clone(cmd);
         else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return {};
 }
     
@@ -298,10 +303,9 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
 shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-
-    std::vector<std::string> vec;
     int cntp = 0;
     kinfo_proc2 *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -312,25 +316,24 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
 
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return vec;}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
     if ((proc_info = kvm_getproc2(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc2), &cntp))) 
     {
         char **cmd = kvm_getargv2(kd.get(), proc_info, 0);
         if (cmd)
             return make_cmd_shell_::clone(cmd);
         else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    return vec;
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+    return {};
 }
     
 #elif defined(__OpenBSD__)
 
 shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-    std::vector<std::string> vec;
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
 
@@ -343,18 +346,17 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     };
 
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return vec;}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc), &cntp))) 
     {
         char **cmd = kvm_getargv(kd.get(), proc_info, 0);
         if (cmd)
             return make_cmd_shell_::clone(cmd);
         else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    kvm_close(kd);
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return {};
 }
     
@@ -365,36 +367,47 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     char **cmd = nullptr;
     proc *proc_info = nullptr;
     user *proc_user = nullptr;
-    kd = kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr);
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return {};}
-    if ((proc_info = kvm_getproc(kd, pid))) 
+
+    struct closer
     {
-        if ((proc_user = kvm_getu(kd, proc_info))) 
+        void operator()(kvm_t * kd)
         {
-            if (!kvm_getcmd(kd, proc_info, proc_user, &cmd, nullptr)) 
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+    if ((proc_info = kvm_getproc(kd.get(), pid))) 
+    {
+        if ((proc_user = kvm_getu(kd.get(), proc_info))) 
+        {
+            if (!kvm_getcmd(kd.get(), proc_info, proc_user, &cmd, nullptr)) 
             {
                 int argc = 0;
                 for (int i = 0; cmd[i] != nullptr; i++)
-                    argc ++;
+                    argc++;
                 return make_cmd_shell_::make(
                         {}, argc, cmd,
-                        +[](int, char ** argv) {::free(argv);})
+                        +[](int, char ** argv) {::free(argv);});
             }
             else
-                BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+                BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         }
         else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    
-    kvm_close(kd);
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return {};
 }
 
 #else
-#error "Platform not supported"
+filesystem::path cmd(boost::process::v2::pid_type, boost::system::error_code & ec)
+{
+  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
+  return "";
+}
 #endif
 
 shell cmd(boost::process::v2::pid_type pid)

src/ext/cwd.cpp

@@ -24,8 +24,11 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <sys/proc_info.h>
-#include <libproc.h>
+#include <TargetConditionals.h>
+#if !TARGET_OS_IOS
+  #include <sys/proc_info.h>
+  #include <libproc.h>
+#endif
 #endif
 
 #if (defined(BOOST_PROCESS_V2_WINDOWS) || defined(__linux__) || defined(__ANDROID__) || defined(__sun))
@@ -46,8 +49,10 @@
 #endif
 
 #if defined(__DragonFly__)
+#include <climits>
 #include <cstring>
-#include <cstdio>
+#include <sys/types.h>
+#include <sys/sysctl.h>
 #endif
 
 #ifdef BOOST_PROCESS_USE_STD_FS
@@ -68,7 +73,7 @@ filesystem::path cwd(HANDLE proc, boost::system::error_code & ec)
     if (!buffer.empty())
       return filesystem::canonical(buffer, ec);
     else 
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return "";
 }
 
@@ -83,7 +88,7 @@ filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code
     };
     std::unique_ptr<void, del> proc{detail::ext::open_process_with_debug_privilege(pid, ec)};
     if (proc == nullptr)
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     else
         return cwd(proc.get(), ec);
     return {};
@@ -98,7 +103,7 @@ filesystem::path cwd(HANDLE proc)
     return res;
 }
 
-#elif (defined(__APPLE__) && defined(__MACH__))
+#elif (defined(__APPLE__) && defined(__MACH__)) && !TARGET_OS_IOS
 
 filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -106,7 +111,7 @@ filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code
     if (proc_pidinfo(pid, PROC_PIDVNODEPATHINFO, 0, &vpi, sizeof(vpi)) > 0)
         return filesystem::canonical(vpi.pvi_cdir.vip_path, ec);
     else
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return "";
 }
 
@@ -141,10 +146,10 @@ filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code
             path = filesystem::canonical(kif.kf_path, ec);
         }
         else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return path;
 }
 
@@ -152,55 +157,16 @@ filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code
 
 filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-    /*
     filesystem::path path;
-    // Official API (broken OS-level) - including code from DragonFly's fstat(1) 
-    // command line interface utility currently requires way too much code FWIW.
-    std::size_t sz = 4, len = 0;
+    char buffer[PATH_MAX];
+    std::size_t sz = 4, len = sizeof(buffer);
     int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_CWD, pid};
-    if (sysctl(mib, sz, nullptr, &len, nullptr, 0) == 0)
+    if (sysctl(mib, sz, buffer, &len, nullptr, 0) == 0)
     {
-        std::vector<char> vecbuff;
-        vecbuff.resize(len);
-        if (sysctl(mib, sz, &vecbuff[0], &len, nullptr, 0) == 0)
-        {
-            path = filesystem::canonical(&vecbuff[0], ec);
-        }    
-        else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    }
+        path = filesystem::canonical(buffer, ec);
+    }    
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    return path;
-    */
-
-    filesystem::path path;
-    /* Probably the hackiest thing ever we are doing here, because the official API is broken OS-level. */
-    FILE *fp = popen(("pos=`ans=\\`/usr/bin/fstat -w -p " + std::to_string(pid) + " | /usr/bin/sed -n 1p\\`; " +
-        "/usr/bin/awk -v ans=\"$ans\" 'BEGIN{print index(ans, \"INUM\")}'`; str=`/usr/bin/fstat -w -p " + 
-        std::to_string(pid) + " | /usr/bin/sed -n 3p`; /usr/bin/awk -v str=\"$str\" -v pos=\"$pos\" " +
-        "'BEGIN{print substr(str, 0, pos + 4)}' | /usr/bin/awk 'NF{NF--};1 {$1=$2=$3=$4=\"\"; print" +
-        " substr($0, 5)'}").c_str(), "r");
-    if (fp) 
-    {
-        char buffer[PATH_MAX];
-        if (fgets(buffer, sizeof(buffer), fp)) 
-        {
-            std::string str = buffer;
-            std::size_t pos = str.find("\n", strlen(buffer) - 1);
-            if (pos != std::string::npos) 
-            {
-                str.replace(pos, 1, "");
-            }
-            path = filesystem::canonical(str.c_str(), ec);
-        }
-        else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-        if (pclose(fp) == -1)
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    }
-    else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return path;
 }
 
@@ -221,20 +187,24 @@ filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code
     {
         std::vector<char> vecbuff;
         vecbuff.resize(len);
-        if (sysctl(mib, 4, &vecbuff[0], &len, nullptr, 0) == 0)
+        if (sysctl(mib, sz, &vecbuff[0], &len, nullptr, 0) == 0)
         {
             path = filesystem::canonical(&vecbuff[0], ec);
         }
         else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return path;
 }
 
 #else
-#error "Platform not supported"
+filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+{
+  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
+  return "";
+}
 #endif
 
 filesystem::path cwd(boost::process::v2::pid_type pid)

src/ext/env.cpp

@@ -21,9 +21,13 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <sys/proc_info.h>
-#include <sys/sysctl.h>
-#include <libproc.h>
+#include <TargetConditionals.h>
+#if !TARGET_OS_IOS
+  #include <algorithm>
+  #include <sys/proc_info.h>
+  #include <sys/sysctl.h>
+  #include <libproc.h>
+#endif
 #endif
 
 #if (defined(__linux__) || defined(__ANDROID__))
@@ -31,12 +35,50 @@
 #endif
 
 #if defined(__FreeBSD__)
-#include <sys/socket.h>
-#include <sys/sysctl.h>
+#include <algorithm>
+#include <cstring>
+#include <fcntl.h>
+#include <kvm.h>
 #include <sys/param.h>
-#include <sys/queue.h>
+#include <sys/sysctl.h>
 #include <sys/user.h>
-#include <libprocstat.h>
+#endif
+
+#if defined(__DragonFly__)
+#include <algorithm>
+#include <cstring>
+#include <sys/types.h>
+#include <kvm.h>
+#endif
+
+#if defined(__NetBSD__)
+#include <algorithm>
+#include <cstring>
+#include <fcntl.h>
+#include <kvm.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#endif
+
+#if defined(__OpenBSD__)
+#include <algorithm>
+#include <cstring>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <fcntl.h>
+#include <kvm.h>
+#endif
+
+#if defined(__sun)
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <kvm.h>
+#include <fcntl.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/user.h>
+#include <sys/proc.h>
 #endif
 
 BOOST_PROCESS_V2_BEGIN_NAMESPACE
@@ -95,7 +137,7 @@ const environment::char_type * dereference(native_env_iterator iterator)
     return iterator;
 }
 
-#elif (defined(__APPLE___) || defined(__MACH__))
+#elif (defined(__APPLE___) || defined(__MACH__)) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun)
 
 void native_env_handle_deleter::operator()(native_env_handle_type h) const
 {
@@ -120,31 +162,6 @@ const environment::char_type * dereference(native_env_iterator iterator)
     return iterator;
 }
 
-
-#elif defined(__FreeBSD__)
-
-void native_env_handle_deleter::operator()(native_env_handle_type h) const
-{
-    delete [] h;
-}
-
-native_env_iterator next(native_env_iterator nh)
-{
-    return ++nh ;
-}
-native_env_iterator find_end(native_env_iterator nh)
-{
-    while (*nh != nullptr)
-      nh++;
-
-    return nh ;
-}
-
-const environment::char_type * dereference(native_env_iterator iterator)
-{
-    return *iterator;
-}
-
 #endif
 
 }
@@ -171,19 +188,19 @@ env_view env(HANDLE proc, boost::system::error_code & ec)
 
     if (error)
     {
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, boost::system::system_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, system_category());
         return {};
     }
 
     if (!ReadProcessMemory(proc, pbi.PebBaseAddress, &peb, sizeof(peb), &nRead))
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
     if (!ReadProcessMemory(proc, peb.ProcessParameters, &upp, sizeof(upp), &nRead))
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
@@ -194,7 +211,7 @@ env_view env(HANDLE proc, boost::system::error_code & ec)
 
     if (!ReadProcessMemory(proc, buf, ev.handle_.get(), len, &nRead))
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
@@ -222,14 +239,14 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     };
     std::unique_ptr<void, del> proc{detail::ext::open_process_with_debug_privilege(pid, ec)};
     if (proc == nullptr)
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     else
 	    return env(proc.get(), ec);
 
 	return {};
 }
 
-#elif (defined(__APPLE___) || defined(__MACH__))
+#elif (defined(__APPLE___) || defined(__MACH__)) && !TARGET_OS_IOS
 
 env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -238,7 +255,7 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     auto size = sizeof(argmax);
     if (sysctl(mib, 2, &argmax, &size, nullptr, 0) == -1)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
@@ -251,7 +268,7 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
     if (sysctl(mib, 3, &*procargs.begin(), &size, nullptr, 0) != 0)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
     std::uint32_t nargs;
@@ -309,7 +326,7 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
         auto r = ::read(f, buf.get() + size, 4096);
         if (r < 0)
         {
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
             ::close(f);
             return {};
         }
@@ -328,69 +345,175 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     return ev;
 }
 
-#elif defined(__FreeBSD__)
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
 env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-  env_view ev;
+  std::vector<char> vec;
+  int cntp = 0;
+  kinfo_proc *proc_info = nullptr;
+  const char *nlistf, *memf;
+  nlistf = memf = "/dev/null";
 
-  unsigned cntp = 0;
-  procstat *proc_stat = procstat_open_sysctl();
-  if (proc_stat != nullptr)
+  struct closer
   {
-    kinfo_proc *proc_info = procstat_getprocs(proc_stat, KERN_PROC_PID, pid, &cntp);
-    if (proc_info != nullptr)
+    void operator()(kvm_t * kd)
     {
-      char **env = procstat_getenvv(proc_stat, proc_info, 0);
-      if (env != nullptr)
+      kvm_close(kd);
+    }
+  };
+
+  std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+  if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp))) {
+    char **env = kvm_getenvv(kd.get(), proc_info, 0);
+    if (env) {
+      for (int i = 0; env[i] != nullptr; i++) 
       {
-        auto e = env;
-        std::size_t n = 0u, len = 0u;
-        while (e && *e != nullptr)
-        {
-          n ++;
-          len += std::strlen(*e);
-          e++;
-        }
-        std::size_t mem_needed =
-            // environ         -  nullptr       - strlen  + null terminators
-            (n * sizeof(char*)) + sizeof(char*) + len     + n;
-
-        char * out = new (std::nothrow) char[mem_needed];
-        if (out != nullptr)
-        {
-          auto eno = reinterpret_cast<char**>(out);
-          auto eeo = eno;
-            auto str = out +  (n * sizeof(char*)) + sizeof(char*);
-          e = env;
-          while (*e != nullptr)
-          {
-            auto len = std::strlen(*e) + 1u;
-            std::memcpy(str, *e, len);
-            *eno = str;
-            str += len;
-            eno ++;
-            e++;
-          }
-          *eno = nullptr;
-
-          ev.handle_.reset(eeo);
-        }
-        else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-
+        for (int j = 0; j < strlen(env[i]); j++)
+          vec.push_back(env[i][j]);
+        vec.push_back('\0');
       }
-      procstat_freeprocs(proc_stat, proc_info);
-
+      vec.push_back('\0');
     }
     else
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    procstat_close(proc_stat);
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
   }
   else
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
+  env_view ev;
+  ev.handle_.reset(new char[vec.size()]());
+  std::copy(vec.begin(), vec.end(), ev.handle_.get());
   return ev;
 }
 
+#elif defined(__NetBSD__)
+env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+{
+  std::vector<char> vec;
+  int cntp = 0;
+  kinfo_proc2 *proc_info = nullptr;
+
+  struct closer
+  {
+    void operator()(kvm_t * kd)
+    {
+      kvm_close(kd);
+    }
+  };
+
+  std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+  if ((proc_info = kvm_getproc2(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc2), &cntp))) {
+    char **env = kvm_getenvv2(kd.get(), proc_info, 0);
+    if (env) {
+      for (int i = 0; env[i] != nullptr; i++) 
+      {
+        for (int j = 0; j < strlen(env[i]); j++)
+          vec.push_back(env[i][j]);
+        vec.push_back('\0');
+      }
+      vec.push_back('\0');
+    }
+    else
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+  }
+  else
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
+  env_view ev;
+  ev.handle_.reset(new char[vec.size()]());
+  std::copy(vec.begin(), vec.end(), ev.handle_.get());
+  return ev;
+}
+#elif defined(__OpenBSD__)
+env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+{
+  std::vector<char> vec;
+  int cntp = 0;
+  kinfo_proc *proc_info = nullptr;
+
+  struct closer
+  {
+    void operator()(kvm_t * kd)
+    {
+      kvm_close(kd);
+    }
+  };
+
+  std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+  if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc), &cntp)))
+  {
+    char **env = kvm_getenvv(kd.get(), proc_info, 0);
+    if (env)
+    {
+      for (int i = 0; env[i] != nullptr; i++) 
+      {
+        for (int j = 0; j < strlen(env[i]); j++)
+          vec.push_back(env[i][j]);
+        vec.push_back('\0');
+      }
+      vec.push_back('\0');
+    }
+    else
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+  }
+  else
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
+  env_view ev;
+  ev.handle_.reset(new char[vec.size()]());
+  std::copy(vec.begin(), vec.end(), ev.handle_.get());
+  return ev;
+}
+#elif defined(__sun)
+env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+{
+  std::vector<char> vec;
+  char **env = nullptr;
+  proc *proc_info = nullptr;
+  user *proc_user = nullptr;
+
+  struct closer
+  {
+    void operator()(kvm_t * kd)
+    {
+      kvm_close(kd);
+    }
+  };
+
+  std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+  if ((proc_info = kvm_getproc(kd.get(), pid))) 
+  {
+    if ((proc_user = kvm_getu(kd.get(), proc_info))) 
+    {
+      if (!kvm_getcmd(kd.get(), proc_info, proc_user, nullptr, &env)) 
+      {
+        for (int i = 0; env[i] != nullptr; i++) 
+        {
+          for (int j = 0; j < strlen(env[i]); j++)
+            vec.push_back(env[i][j]);
+          vec.push_back('\0');
+        }
+        vec.push_back('\0');
+        free(env);
+      }
+      else
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+    }
+    else
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+  }
+  else
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
+  env_view ev;
+  ev.handle_.reset(new char[vec.size()]());
+  std::copy(vec.begin(), vec.end(), ev.handle_.get());
+  return ev;
+}
 #endif
 
 env_view env(boost::process::v2::pid_type pid)

src/ext/exe.cpp

@@ -25,8 +25,11 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <sys/proc_info.h>
-#include <libproc.h>
+#include <TargetConditionals.h>
+#if !TARGET_OS_IOS
+  #include <sys/proc_info.h>
+  #include <libproc.h>
+#endif
 #endif
 
 #if (defined(BOOST_PROCESS_V2_WINDOWS) || defined(__linux__) || defined(__ANDROID__) || defined(__sun))
@@ -36,7 +39,7 @@
 #if (defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__))
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 #include <alloca.h>
 #endif
 #endif
@@ -80,7 +83,7 @@ filesystem::path exe(HANDLE proc, boost::system::error_code & ec)
         return filesystem::canonical(buffer, ec);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
 
     return "";
 }
@@ -106,14 +109,14 @@ filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code
         };
         std::unique_ptr<void, del> proc{detail::ext::open_process_with_debug_privilege(pid, ec)};
         if (proc == nullptr)
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         else
             return exe(proc.get(), ec);
     }
     return "";
 }
 
-#elif (defined(__APPLE__) && defined(__MACH__))
+#elif (defined(__APPLE__) && defined(__MACH__)) && !TARGET_OS_IOS
 
 filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -122,7 +125,7 @@ filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code
     {
         return filesystem::canonical(buffer, ec);
     }
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return "";
 }
 
@@ -162,7 +165,7 @@ filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code
         }
     }
 
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return "";
 }
 
@@ -170,12 +173,16 @@ filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code
 
 filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-    BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, boost::system::system_category())
+    BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
     return "";
 }
 
 #else
-#error "Platform not supported"
+filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+{
+  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
+  return "";
+}
 #endif
 
 filesystem::path exe(boost::process::v2::pid_type pid)

src/ext/proc_info.cpp

@@ -16,14 +16,6 @@
 
 #include <string>
 
-#if (defined(__APPLE__) && defined(__MACH__))
-#include <cstdlib>
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <sys/proc_info.h>
-#include <libproc.h>
-#endif
-
 BOOST_PROCESS_V2_BEGIN_NAMESPACE
 
 namespace detail
@@ -51,19 +43,19 @@ std::wstring cwd_cmd_from_proc(HANDLE proc, int type, boost::system::error_code
 
     if (error)
     {
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, boost::system::system_category())
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, system_category());
         return {};
     }
 
     if (!ReadProcessMemory(proc, pbi.PebBaseAddress, &peb, sizeof(peb), &nRead))
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
     if (!ReadProcessMemory(proc, peb.ProcessParameters, &upp, sizeof(upp), &nRead))
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
@@ -82,7 +74,7 @@ std::wstring cwd_cmd_from_proc(HANDLE proc, int type, boost::system::error_code
 
     if (!ReadProcessMemory(proc, buf, &buffer[0], len, &nRead))
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
 
@@ -115,7 +107,7 @@ HANDLE open_process_with_debug_privilege(boost::process::v2::pid_type pid, boost
     if (!proc)
         proc = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
     if (!proc)
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return proc;
 }
 #endif

src/pid.cpp

@@ -17,8 +17,11 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <sys/proc_info.h>
-#include <libproc.h>
+#include <TargetConditionals.h>
+#if !TARGET_OS_IOS
+  #include <sys/proc_info.h>
+  #include <libproc.h>
+#endif
 #endif
 
 #if (defined(__linux__) || defined(__ANDROID__))
@@ -26,10 +29,11 @@
 #endif
 
 #if defined(__FreeBSD__)
-#include <sys/types.h>
+#include <fcntl.h>
+#include <kvm.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
 #include <sys/user.h>
-#include <libutil.h>
-#include <cstdlib>
 #endif
 
 #if (defined(__DragonFly__) ||  defined(__OpenBSD__))
@@ -48,6 +52,7 @@
 #endif
 
 #if defined(__sun)
+#include <fcntl.h>
 #include <sys/types.h>
 #include <kvm.h>
 #include <sys/param.h>
@@ -71,7 +76,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     HANDLE hp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
     if (!hp)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
     PROCESSENTRY32 pe;
@@ -93,7 +98,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     HANDLE hp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
     if (!hp)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     }
     PROCESSENTRY32 pe;
@@ -120,7 +125,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     HANDLE hp = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
     if (!hp)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
     PROCESSENTRY32 pe;
@@ -140,7 +145,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     return vec;
 }
 
-#elif (defined(__APPLE__) && defined(__MACH__))
+#elif (defined(__APPLE__) && defined(__MACH__)) && !TARGET_OS_IOS
 
 std::vector<pid_type> all_pids(boost::system::error_code & ec)
 {
@@ -149,7 +154,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     const auto sz = proc_listpids(PROC_ALL_PIDS, 0, &vec[0], sizeof(pid_type) * vec.size());
     if (sz < 0)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
     vec.resize(sz);
@@ -162,7 +167,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     proc_bsdinfo proc_info;
     if (proc_pidinfo(pid, PROC_PIDTBSDINFO, 0, &proc_info, sizeof(proc_info)) <= 0)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     }
     else
@@ -177,7 +182,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     const auto sz = proc_listpids(PROC_PPID_ONLY, (uint32_t)pid, &vec[0], sizeof(pid_type) * vec.size());
     if (sz < 0)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return {};
     }
     vec.resize(sz);
@@ -192,7 +197,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     DIR *proc = opendir("/proc");
     if (!proc)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     } 
     struct dirent *ent = nullptr;
@@ -215,9 +220,9 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     if (!stat)
     {
         if (errno == ENOENT)
-            BOOST_PROCESS_V2_ASSIGN_EC(ec, ESRCH, system_category())
+            BOOST_PROCESS_V2_ASSIGN_EC(ec, ESRCH, system_category());
         else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     } 
     else
@@ -242,7 +247,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
             if (!token)
             {
                 fclose(stat);
-                BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+                BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
                 return ppid;
             }
         }
@@ -274,39 +279,89 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
 {
     std::vector<pid_type> vec;
     int cntp = 0;
-    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
-    if (proc_info) 
+    kinfo_proc *proc_info = nullptr;
+    const char *nlistf, *memf;
+    nlistf = memf = "/dev/null";
+  
+    struct closer
+    {
+        void operator()(kvm_t * kd)
+        {
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
+    if (!kd) 
+    {
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        return vec;
+    }
+    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp))) 
     {
         vec.reserve(cntp);
-        for (int i = 0; i < cntp; i++)
+        for (int i = 0; i < cntp; i++) 
             vec.push_back(proc_info[i].ki_pid);
-        free(proc_info);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
 pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
 {
     pid_type ppid = static_cast<pid_type>(-1);
-    kinfo_proc *proc_info = kinfo_getproc(pid);
-    if (proc_info)
+    int cntp = 0;
+    kinfo_proc *proc_info = nullptr;
+    const char *nlistf, *memf;
+    nlistf = memf = "/dev/null";
+  
+    struct closer
+    {
+        void operator()(kvm_t * kd)
+        {
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)}; 
+    if (!kd) 
+    {
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        return ppid;
+    }
+    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp)))
     {
         ppid = proc_info->ki_ppid;
-        free(proc_info);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return ppid;
 }
 
 std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec) 
 {
     std::vector<pid_type> vec;
-    int cntp = 0; 
-    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
-    if (proc_info)
+    int cntp = 0;
+    kinfo_proc *proc_info = nullptr;
+    const char *nlistf, *memf;
+    nlistf = memf = "/dev/null";
+  
+    struct closer
+    {
+        void operator()(kvm_t * kd)
+        {
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
+    if (!kd) 
+    {
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        return vec;
+    }
+    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp)))
     {
         vec.reserve(cntp);
         for (int i = 0; i < cntp; i++)
@@ -316,10 +371,9 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
                 vec.push_back(proc_info[i].ki_pid);
             }
         }
-        free(proc_info);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
@@ -332,6 +386,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -343,7 +398,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
     if (!kd) 
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp))) 
@@ -354,7 +409,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
                 vec.push_back(proc_info[i].kp_pid);
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
@@ -365,6 +420,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -376,7 +432,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)}; 
     if (!kd) 
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     }
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp)))
@@ -387,7 +443,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
         }
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return ppid;
 }
 
@@ -398,6 +454,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -409,7 +466,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
     if (!kd) 
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp)))
@@ -424,7 +481,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
         }
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
@@ -435,6 +492,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc2  *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -446,7 +504,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
     if (!kd)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     } 
     if ((proc_info = kvm_getproc2(kd.get(), KERN_PROC_ALL, 0, sizeof(struct kinfo_proc2), &cntp)))
@@ -458,7 +516,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
         }
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
@@ -467,6 +525,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     pid_type ppid = static_cast<pid_type>(-1);
     int cntp = 0;
     kinfo_proc2 *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -478,7 +537,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
     if (!kd) 
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     }
     if ((proc_info = kvm_getproc2(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc2), &cntp)))
@@ -486,7 +545,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
         ppid = proc_info->p_ppid;
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return ppid;
 }
 
@@ -495,6 +554,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc2 *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -506,7 +566,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
     if (!kd) 
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
     if ((proc_info = kvm_getproc2(kd.get(), KERN_PROC_ALL, 0, sizeof(struct kinfo_proc2), &cntp)))
@@ -521,7 +581,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
         }
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
@@ -532,6 +592,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -543,7 +604,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
     if (!kd)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     } 
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &cntp)))
@@ -551,14 +612,14 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
         vec.reserve(cntp);
         for (int i = cntp - 1; i >= 0; i--)
         {
-            if (proc_info[i].kp_pid >= 0) 
+            if (proc_info[i].p_pid >= 0)
             {
-                vec.push_back(proc_info[i].kp_pid);
+                vec.push_back(proc_info[i].p_pid);
             }
         }
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
@@ -567,6 +628,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     pid_type ppid = static_cast<pid_type>(-1);
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -578,7 +640,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
     if (!kd)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     }
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc), &cntp)))
@@ -586,7 +648,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
         ppid = proc_info->p_ppid;
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return ppid;
 }
 
@@ -595,6 +657,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -606,7 +669,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)}; 
     if (!kd) 
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &cntp)))
@@ -621,7 +684,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
         }
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return vec;
 }
 
@@ -633,6 +696,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::vector<pid_type> vec;
     struct pid cur_pid;
     proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -644,18 +708,18 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
     if (!kd)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     } 
-    while ((proc_info = kvm_nextproc(kd)))
+    while ((proc_info = kvm_nextproc(kd.get())))
     {
-        if (kvm_kread(kd, (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
+        if (kvm_kread(kd.get(), (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
         {
             vec.insert(vec.begin(), cur_pid.pid_id);
         }
         else
         {
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
             break;
         }
     }
@@ -666,6 +730,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
 {
     pid_type ppid = static_cast<pid_type>(-1);
     proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -677,15 +742,15 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
     if (!kd)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     }
-    if ((proc_info = kvm_getproc(kd, pid)))
+    if ((proc_info = kvm_getproc(kd.get(), pid)))
     {
         ppid = proc_info->p_ppid;
     }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
     return ppid;
 }
 
@@ -694,6 +759,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::vector<pid_type> vec;
     struct pid cur_pid;
     proc *proc_info = nullptr;
+
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -702,23 +768,23 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
         }
     };
 
-    std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr);
+    std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
     if (!kd)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
-    while ((proc_info = kvm_nextproc(kd)))
+    while ((proc_info = kvm_nextproc(kd.get())))
     {
         if (proc_info->p_ppid == pid)
         {
-            if (kvm_kread(kd, (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
+            if (kvm_kread(kd.get(), (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
             {
                 vec.insert(vec.begin(), cur_pid.pid_id);
             }
             else
             {
-                BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+                BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
                 break;
             }
         }
@@ -727,7 +793,21 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
 }
 
 #else
-#error "Platform not supported"
+std::vector<pid_type> all_pids(boost::system::error_code & ec)
+{
+  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
+  return {};
+}
+pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
+{
+  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
+  return pid;
+}
+std::vector<pid_type> child_pids(pid_type, boost::system::error_code & ec)
+{
+  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
+  return {};
+}
 #endif
 
 std::vector<pid_type> all_pids()

src/posix/close_handles.cpp

@@ -17,10 +17,9 @@
 // linux has close_range since 5.19
 
 
-#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+#if defined(__FreeBSD__)
 
 // https://www.freebsd.org/cgi/man.cgi?query=close_range&apropos=0&sektion=0&manpath=FreeBSD+13.1-RELEASE+and+Ports&arch=default&format=html
-// https://man.netbsd.org/closefrom.3
 // __FreeBSD__
 // 
 // gives us
@@ -45,9 +44,10 @@ int fdwalk(int (*func)(void *, int), void *cd);
 
 #include <linux/version.h>
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0) // kernel has close_range
+// kernel has close_range
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0) && !defined(BOOST_PROCESS_V2_POSIX_FORCE_DISABLE_CLOSE_RANGE)
 
-#include <gnu/libc-version.h>
+// version is included by stdlib.h #include <gnu/libc-version.h>
 #if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 34) // glibc is compiled with close_range support
 // https://man7.org/linux/man-pages/man2/close_range.2.html
 
@@ -60,6 +60,10 @@ int fdwalk(int (*func)(void *, int), void *cd);
 #if defined(SYS_close_range)
 
 #define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1
+#if !defined(CLOSE_RANGE_UNSHARE)
+#define CLOSE_RANGE_UNSHARE 2
+#endif
+
 int close_range(unsigned int first, unsigned int last, int flags)
 {
   return ::syscall(SYS_close_range, first, last, flags);
@@ -215,4 +219,4 @@ void close_all(const std::vector<int> & whitelist, error_code & ec)
 
 BOOST_PROCESS_V2_END_NAMESPACE
 
-#endif
+#endif

src/shell.cpp

@@ -19,7 +19,7 @@
 #if defined(BOOST_PROCESS_V2_WINDOWS)
 #include <windows.h>
 #include <shellapi.h>
-#else
+#elif !defined(__OpenBSD__)
 #include <wordexp.h>
 #endif
 
@@ -30,7 +30,7 @@ BOOST_PROCESS_V2_DECL const error_category& get_shell_category()
 {
     return system_category();
 }
-#else
+#elif !defined(__OpenBSD__)
 
 struct shell_category_t final : public error_category
 {
@@ -38,7 +38,7 @@ struct shell_category_t final : public error_category
 
     const char* name() const noexcept
     {
-        return "process.v2.utf8";
+        return "process.v2.shell";
     }
     std::string message(int value) const
     {
@@ -66,6 +66,13 @@ BOOST_PROCESS_V2_DECL const error_category& get_shell_category()
     return instance;
 }
 
+#else
+
+const error_category& get_shell_category()
+{
+    return system_category();
+}
+
 #endif
 
 #if defined (BOOST_PROCESS_V2_WINDOWS)
@@ -92,7 +99,7 @@ auto shell::args() const-> args_type
     return input_.c_str();
 }
 
-#else
+#elif !defined(__OpenBSD__)
 
 void shell::parse_()
 {
@@ -135,6 +142,22 @@ auto shell::args() const -> args_type
         return const_cast<const char**>(argv());
 }
 
+#else
+
+void shell::parse_()
+{
+    error_code ec;
+    BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
+    throw system_error(ec, "shell::parse");
+}
+
+shell::~shell() = default;
+
+auto shell::args() const -> args_type
+{
+    return nullptr;
+}
+
 #endif
 
 BOOST_PROCESS_V2_END_NAMESPACE

test/v1/Jamfile.jam

@@ -9,25 +9,23 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 
-import os ;
-
-if [ os.name ] = NT
-{
-  lib ws2_32 ;
-  lib shell32 ;
-  lib Advapi32 ;
-  lib Ntdll ;
-}
+lib ws2_32 ;
+lib shell32 ;
+lib Advapi32 ;
+lib Ntdll ;
 
 project : requirements
+  <library>/boost/process//boost_process
   <define>BOOST_ASIO_NO_DEPRECATED
   <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
   <toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE
   <toolset>msvc:<cxxflags>/bigobj
   <target-os>windows:<define>WIN32_LEAN_AND_MEAN
   <target-os>linux:<linkflags>-lpthread
+  <target-os>freebsd:<linkflags>-lpthread
   <os>NT,<toolset>cw:<library>ws2_32
   <os>NT,<toolset>gcc:<library>ws2_32
+  <library>/boost/test//included
 ;
 
 
@@ -35,16 +33,18 @@ project : requirements
 import testing ;
 
 
-alias program_options  : /boost//program_options : <link>static ;
-alias filesystem       : /boost//filesystem      ;
-alias iostreams        : /boost//iostreams       ;
-alias system           : /boost//system          ;
-alias thread           : /boost//thread          ;
-alias coroutine        : /boost//coroutine       : <link>static ;
+alias program_options  : usage-requirements <library>/boost/program_options//boost_program_options ;
+alias filesystem       : usage-requirements <library>/boost/filesystem//boost_filesystem ;
+alias iostreams        : usage-requirements <library>/boost/iostreams//boost_iostreams ;
+alias system           : usage-requirements <library>/boost/system//boost_system ;
+alias thread           : usage-requirements <library>/boost/thread//boost_thread ;
+alias scope_exit       : usage-requirements <library>/boost/scope_exit//boost_scope_exit ;
+alias lambda           : usage-requirements <library>/boost/lambda//boost_lambda ;
+alias chrono           : usage-requirements <library>/boost/chrono//boost_chrono ;
 
 lib multi_ref : multi_ref1.cpp multi_ref2.cpp system : <target-os>windows:<source>shell32 ;
 
-exe sparring_partner : sparring_partner.cpp program_options system filesystem iostreams :
+exe sparring_partner : sparring_partner.cpp program_options system filesystem iostreams lambda :
     <warnings>off <target-os>windows:<source>shell32 <target-os>windows:<source>Ntdll
     ;
 
@@ -100,15 +100,15 @@ test-suite with-valgrind :
     [ run env.cpp     program_options system filesystem       : [ test-options env ] : sparring_partner ]
     [ run group.cpp     system thread filesystem              : [ test-options group ] : sub_launch ]
     [ run group.cpp          system thread filesystem         : [ test-options group ] : 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         : [ test-options group_wait ] : sparring_partner : <target-os>darwin:<build>no <target-os>freebsd:<build>no ]
+    [ run group_wait.cpp system thread filesystem scope_exit  : [ test-options group_wait ] : sparring_partner : <target-os>darwin:<build>no <target-os>freebsd:<build>no ]
 	[ run limit_fd.cpp     program_options system filesystem  : [ test-options limit_fd ] : sparring_partner : <target-os>freebsd:<build>no ]
     [ run run_exe.cpp filesystem                              : : sparring_partner ]
     [ run run_exe_path.cpp filesystem                         : [ test-options run_exe_path ] : sparring_partner ]
     [ run search_path.cpp filesystem system                   : [ test-options search_path ] : : <target-os>windows:<source>shell32 ]
     [ run shell.cpp filesystem system                         : [ test-options shell ] : sparring_partner : <target-os>darwin:<build>no ]
     [ run shell_path.cpp  filesystem system                   : [ test-options shell_path ] ]
-    [ run system_test1.cpp filesystem system                  : [ test-options system_test1 ] : sparring_partner ]
-    [ run system_test2.cpp filesystem system                  : [ test-options system_test2 ] : sparring_partner ]
+    [ run system_test1.cpp filesystem system chrono           : [ test-options system_test1 ] : sparring_partner ]
+    [ run system_test2.cpp filesystem system chrono           : [ test-options system_test2 ] : sparring_partner ]
     [ run spawn.cpp filesystem system                         : [ test-options spawn ] : sparring_partner ]
     [ run start_dir.cpp   filesystem system                   : [ test-options start_dir ] : sparring_partner ]
     [ run terminate.cpp system filesystem                     : [ test-options terminate ] : sparring_partner : <target-os>freebsd:<build>no ]
@@ -123,13 +123,10 @@ test-suite with-valgrind :
    : <dependency>bare ;
 
 test-suite without-valgrind :
-    [ run async_system_future.cpp filesystem system coroutine           : [ test-options async_system_future ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
-    [ run async_system_stackful.cpp filesystem system coroutine         : [ test-options async_system_stackful ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+    [ run async_system_future.cpp filesystem system                     : [ test-options async_system_future ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+#    [ run async_system_stackful.cpp filesystem system coroutine         : [ test-options async_system_stackful ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
 #   [ run async_system_stackful_error.cpp filesystem system coroutine   : [ test-options async_system_stackful_error ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
-    [ run async_system_stackful_except.cpp filesystem system coroutine  : [ test-options async_system_stackful_except ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
-    [ run async_system_stackless.cpp filesystem system coroutine        : [ test-options async_system_stackless ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+#    [ run async_system_stackful_except.cpp filesystem system coroutine  : [ test-options async_system_stackful_except ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+    [ run async_system_stackless.cpp filesystem system                  : [ test-options async_system_stackless ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
     [ run vfork.cpp     system filesystem                               : [ test-options vfork ] : sparring_partner : <build>no <target-os>linux:<build>yes ]
     ;
-
-
-alias v2-tests : v2//standalone v2//with_target ;

test/v1/async.cpp

@@ -21,7 +21,7 @@
 
 #include <boost/system/error_code.hpp>
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/asio/deadline_timer.hpp>
+#include <boost/asio/steady_timer.hpp>
 
 using namespace std;
 
@@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(async_wait, *boost::unit_test::timeout(5))
     bool exit_called_for_c1 = false;
     int exit_code_c1 = 0;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(2)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(2)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     bp::child c1(master_test_suite().argv[1],
@@ -97,7 +97,7 @@ BOOST_AUTO_TEST_CASE(async_wait_sync_wait, *boost::unit_test::timeout(5))
     int exit_code = 0;
     std::error_code ec;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(3)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(3)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     bp::child c1(
@@ -140,10 +140,10 @@ BOOST_AUTO_TEST_CASE(async_wait_different_contexts, *boost::unit_test::timeout(1
     boost::asio::io_context io_context1;
     boost::asio::io_context io_context2;
 
-    boost::asio::deadline_timer timeout1{io_context1, boost::posix_time::seconds(2)};
+    boost::asio::steady_timer timeout1{io_context1, std::chrono::seconds(2)};
     timeout1.async_wait([&](boost::system::error_code ec){if (!ec) io_context1.stop();});
 
-    boost::asio::deadline_timer timeout2{io_context2, boost::posix_time::seconds(7)};
+    boost::asio::steady_timer timeout2{io_context2, std::chrono::seconds(7)};
     timeout2.async_wait([&](boost::system::error_code ec){if (!ec) io_context2.stop();});
     std::error_code ec;
 
@@ -208,7 +208,7 @@ BOOST_AUTO_TEST_CASE(async_wait_abort, *boost::unit_test::timeout(5))
 
     std::error_code ec;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(5)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(5)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     bool exit_called = false;
@@ -245,7 +245,7 @@ BOOST_AUTO_TEST_CASE(async_future, *boost::unit_test::timeout(3))
 
     boost::asio::io_context io_context;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(2)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(2)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     std::error_code ec;
@@ -278,7 +278,7 @@ BOOST_AUTO_TEST_CASE(async_out_stream, *boost::unit_test::timeout(5))
 
     boost::asio::streambuf buf;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(2)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(2)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     bp::child c(master_test_suite().argv[1],
@@ -318,7 +318,7 @@ BOOST_AUTO_TEST_CASE(async_in_stream, *boost::unit_test::timeout(5))
     std::ostream ostr(&in_buf);
     ostr << "-string" << endl ;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(2)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(2)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     bp::child c(
@@ -355,7 +355,7 @@ BOOST_AUTO_TEST_CASE(async_error, *boost::unit_test::timeout(3))
 
     boost::asio::io_context io_context;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(2)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(2)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     bool exit_called = false;
@@ -386,7 +386,7 @@ BOOST_AUTO_TEST_CASE(mixed_async, *boost::unit_test::timeout(5))
 
     boost::asio::io_context io_context;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(2)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(2)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
     bool exit_called = false;

test/v1/exit_code.cpp

@@ -110,7 +110,7 @@ BOOST_AUTO_TEST_CASE(async_wait, *boost::unit_test::timeout(10))
 
     boost::asio::io_context io_context;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(3)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(3)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
 
@@ -148,12 +148,17 @@ BOOST_AUTO_TEST_CASE(async_nowait, *boost::unit_test::timeout(10))
     boost::asio::io_context io_context;
     bp::child c(
             master_test_suite().argv[1],
-            "test", "--exit-code", "221",
+            "test", "--exit-code", "121",
             ec,
             bp::on_exit=[](int exit_code, std::error_code) mutable {},
             io_context
     );
     BOOST_REQUIRE(!ec);
-    io_context.run_for(std::chrono::milliseconds(100));
-    BOOST_CHECK_EQUAL(221, c.exit_code());
+    while (c.running())
+    {
+      io_context.run_for(std::chrono::milliseconds(10));
+      io_context.restart();
+    }
+
+    BOOST_CHECK_EQUAL(121, c.exit_code());
 }

test/v1/system_test2.cpp

@@ -19,7 +19,7 @@
 #include <boost/chrono.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/asio/steady_timer.hpp>
-#include <boost/asio/deadline_timer.hpp>
+#include <boost/asio/steady_timer.hpp>
 
 #include <boost/process/v1/error.hpp>
 #include <boost/process/v1/io.hpp>

test/v1/wait.cpp

@@ -53,7 +53,7 @@ BOOST_AUTO_TEST_CASE(async_wait, *boost::unit_test::timeout(4))
     std::error_code ec;
     bool called = false;
 
-    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(3)};
+    boost::asio::steady_timer timeout{io_context, std::chrono::seconds(3)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
 

test/v2/Jamfile.jam

@@ -4,19 +4,15 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 
-import os ;
-
-if [ os.name ] = NT
-{
-  lib ws2_32 ;
-  lib shell32 ;
-  lib Advapi32 ;
-  lib Ntdll ;
-  lib user32 ;
-  lib Bcrypt ;
-}
+lib ws2_32 ;
+lib shell32 ;
+lib Advapi32 ;
+lib Ntdll ;
+lib user32 ;
+lib Bcrypt ;
 
 project : requirements
+  <library>/boost/process//boost_process
   <define>BOOST_ASIO_NO_DEPRECATED
   <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
   <toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE
@@ -24,42 +20,44 @@ project : requirements
   <target-os>windows:<define>WIN32_LEAN_AND_MEAN
   <target-os>windows:<define>_WIN32_WINNT=0x0601
   <target-os>linux:<linkflags>-lpthread
-  <target-os>freebsd:<linkflags>-lutil
+  <target-os>freebsd:<linkflags>-lpthread
   <target-os>freebsd:<linkflags>-lkvm
-  <target-os>freebsd:<linkflags>-lprocstat
+  <target-os>bsd:<linkflags>-lpthread
   <target-os>bsd:<linkflags>-lkvm
+  <target-os>netbsd:<linkflags>-lpthread
+  <target-os>netbsd:<linkflags>-lkvm
+  <target-os>openbsd:<linkflags>-lpthread
+  <target-os>openbsd:<linkflags>-lkvm
+  <target-os>solaris:<linkflags>-lpthread
+  <target-os>solaris:<linkflags>-lkvm
   <os>NT,<toolset>cw:<library>ws2_32
   <os>NT,<toolset>gcc:<library>ws2_32
   <os>NT,<toolset>gcc:<library>Bcrypt
   <define>BOOST_PROCESS_V2_SEPARATE_COMPILATION=1
+  <library>/boost/test//included
 ;
 
 import testing ;
 
-alias filesystem   : /boost//filesystem : <link>static ;
-
 exe target : target.cpp :
     <warnings>off <target-os>windows:<source>shell32
                   <target-os>windows:<source>Ntdll
+
     ;
 
-lib test_impl : test_impl.cpp filesystem /boost//process :
-        <define>BOOST_PROCESS_V2_SEPARATE_COMPILATION=1
-        <define>BOOST_TEST_IGNORE_SIGCHLD=1
-        <link>static
-        ;
+local test_impl = test_impl.cpp /boost/process//boost_process /boost/test//boost_unit_test_framework ;
 
 test-suite standalone :
-    [ run utf8.cpp test_impl ]
-    [ run cstring_ref.cpp test_impl ]
-    [ run environment.cpp test_impl ]
-    [ run shell.cpp test_impl ]
+    [ run utf8.cpp        $(test_impl) ]
+    [ run cstring_ref.cpp $(test_impl) ]
+    [ run environment.cpp $(test_impl) ]
+    [ run shell.cpp       $(test_impl) ]
     ;
 
 test-suite with_target :
-    [ run pid.cpp     test_impl : --log_level=all --catch_system_errors=no -- : target ]
-    [ run process.cpp test_impl : --log_level=all --catch_system_errors=no -- : target ]
-    [ run windows.cpp test_impl : --log_level=all --catch_system_errors=no -- : target : <build>no <target-os>windows:<build>yes <target-os>windows:<source>Advapi32 ]
-    [ run ext.cpp     test_impl : --log_level=all --catch_system_errors=no -- : target : <target-os>darwin:<build>no ]
+    [ run pid.cpp     $(test_impl) : --log_level=all --catch_system_errors=no -- : target ]
+    [ run process.cpp $(test_impl) : --log_level=all --catch_system_errors=no -- : target ]
+    [ run windows.cpp $(test_impl) : --log_level=all --catch_system_errors=no -- : target : <build>no <target-os>windows:<build>yes <target-os>windows:<source>Advapi32 ]
+    [ run ext.cpp     $(test_impl) : --log_level=all --catch_system_errors=no -- : target : <target-os>darwin:<build>no ]
     ;
 

test/v2/process.cpp

@@ -9,9 +9,6 @@
 #define BOOST_ALL_NO_LIB 1
 #endif // !defined(BOOST_ALL_NO_LIB)
 
-#if defined(BOOST_FILESYSTEM_DYN_LINK)
-#undef BOOST_FILESYSTEM_DYN_LINK
-#endif
 #define BOOST_TEST_IGNORE_SIGCHLD 1
 
 #if  true //defined(BOOST_POSIX_API)
@@ -34,6 +31,7 @@
 #include <boost/test/unit_test.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/asio/connect_pipe.hpp>
+#include <boost/asio/cancel_after.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/readable_pipe.hpp>
 #include <boost/asio/read.hpp>
@@ -55,9 +53,9 @@ BOOST_AUTO_TEST_CASE(exit_code_sync)
 {
     using boost::unit_test::framework::master_test_suite;
     const auto pth =  master_test_suite().argv[1];
-    
+
     boost::asio::io_context ctx;
-    
+
     BOOST_CHECK_EQUAL(bpv::process(ctx, pth, {"exit-code", "0"}).wait(), 0);
     BOOST_CHECK_EQUAL(bpv::execute(bpv::process(ctx, pth, {"exit-code", "1"})), 1);
     std::vector<std::string> args = {"exit-code", "2"};
@@ -85,7 +83,7 @@ BOOST_AUTO_TEST_CASE(exit_code_async)
 
     int called = 0;
     printf("Setting up processes\n");
-    
+
     bpv::process proc1(ctx, pth, {"exit-code", "0"});
     bpv::process proc3(ctx, pth, {"exit-code", "2"});
     bpv::process proc4(ctx, pth, {"exit-code", "42"});
@@ -200,7 +198,7 @@ BOOST_AUTO_TEST_CASE(print_args_out)
 {
   using boost::unit_test::framework::master_test_suite;
   const auto pth =  master_test_suite().argv[1];
-  
+
   asio::io_context ctx;
 
   asio::readable_pipe rp{ctx};
@@ -296,7 +294,7 @@ BOOST_AUTO_TEST_CASE(echo_file)
 {
   using boost::unit_test::framework::master_test_suite;
   const auto pth =  master_test_suite().argv[1];
-  
+
   asio::io_context ctx;
 
   asio::readable_pipe rp{ctx};
@@ -476,7 +474,7 @@ BOOST_AUTO_TEST_CASE(environment)
 
   sub_env.push_back("FOOBAR=FOO-BAR");
   BOOST_CHECK_EQUAL("FOO-BAR", read_env("FOOBAR", bpv::process_environment{sub_env}));
-  
+
   sub_env.push_back("XYZ=ZYX");
   auto itr = std::find_if(sub_env.begin(), sub_env.end(), [](const bpv::environment::key_value_pair & kv) {return kv.key() == bpv::environment::key("PATH");});
   path += static_cast<char>(bpv::environment::delimiter);
@@ -511,7 +509,7 @@ BOOST_AUTO_TEST_CASE(exit_code_as_error)
   bpv::process proc3(ctx, pth, {"sleep", "2000"});
 
   int called = 0;
-  
+
   proc3.terminate();
 
 
@@ -642,6 +640,30 @@ BOOST_AUTO_TEST_CASE(async_request_exit)
     ctx.run();
 }
 
+BOOST_AUTO_TEST_CASE(async_cancel_wait)
+{
+  asio::io_context ctx;
+  using boost::unit_test::framework::master_test_suite;
+  const auto pth = bpv::filesystem::absolute(master_test_suite().argv[1]);
+
+  bpv::process proc(ctx, pth, {"sleep", "1000"});
+
+  asio::steady_timer tim{ctx, std::chrono::milliseconds(250)};
+  asio::cancellation_signal sig;
+
+  // check that the async_wait gets properly cancelled
+  proc.async_wait(asio::cancel_after(std::chrono::milliseconds(100),
+                         [&](boost::system::error_code ec, int)
+                         {
+                           BOOST_CHECK(ec == asio::error::operation_aborted);
+                           BOOST_CHECK(proc.running());
+                           if (proc.running())
+                             proc.terminate();
+                         }));
+
+  ctx.run();
+}
+
 
 BOOST_AUTO_TEST_SUITE_END();
 

test/v2/test_impl.cpp

@@ -5,4 +5,4 @@
 
 #define BOOST_TEST_IGNORE_SIGCHLD
 #define BOOST_TEST_MODULE process_v2_test
-#include <boost/test/included/unit_test.hpp>
+#include <boost/test/unit_test.hpp>

test/v2/windows.cpp

@@ -9,10 +9,6 @@
 #define BOOST_ALL_NO_LIB 1
 #endif // !defined(BOOST_ALL_NO_LIB)
 
-#if defined(BOOST_FILESYSTEM_DYN_LINK)
-#undef BOOST_FILESYSTEM_DYN_LINK
-#endif
-
 // Test that header file is self-contained.
 #include <boost/process/v2/process.hpp>