added CLOSE_RANGE_UNSHARE defined for syscall of close_range.

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

@@ -1,47 +0,0 @@
-# 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,8 +5,7 @@
 
 import os ;
 import feature ;
-import-search /boost/config/checks ;
+import ../../config/checks/config : requires ;
-import config : requires ;
 
 project : requirements
   <define>BOOST_ASIO_NO_DEPRECATED
@@ -16,11 +15,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
@@ -41,33 +40,26 @@ alias process_sources
      shell.cpp
    ;
 
-lib shell32 ;
+if [ os.name ] = NT
-lib advapi32 ;
+{
-lib ntdll ;
+  lib shell32 ;
-lib user32 ;
+  lib Advapi32 ;
-lib ws2_32 ;
+  lib Ntdll ;
-
+  lib user32 ;
-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_filesystem
+     <boost.process.fs>boost:<library>/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>Ntdll
-     <target-os>windows:<library>advapi32
+     <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_filesystem
+     <boost.process.fs>boost:<library>/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 : ../include ;
+path-constant INCLUDES : ../../.. ;
 
 doxygen reference_v1
 :
@@ -63,10 +63,11 @@ 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= \\
@@ -98,7 +99,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 next release (1.88). Use v2 for new projects.]
+[note Process v1 will be deprecated in the future. 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_v1.xml]
+[xinclude reference_v2.xml]
 
 [endsect]

doc/v2/introduction.qbk

@@ -73,6 +73,14 @@ 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
-  <library>/boost/process//boost_process
+  <include>../../..
   <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
   <target-os>windows:<define>WIN32_LEAN_AND_MEAN
 ;

example/v2/Jamfile.jam

@@ -4,12 +4,14 @@
 # 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 ;
 
-exe intro : intro.cpp ;
+alias filesystem   : /boost//filesystem : <link>static ;
-exe intro_popen : intro_popen.cpp : <boost.process.fs>boost ;
+
+exe intro : intro.cpp filesystem ;
+exe intro_popen : intro_popen.cpp filesystem ;

include/boost/process/v1/pipe.hpp

@@ -257,16 +257,7 @@ struct basic_pipebuf : std::basic_streambuf<CharT, Traits>
     {
         if (!is_open())
             return nullptr;
-        try {
+        overflow(Traits::eof());
-          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&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                        ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                        ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                        net::execution::is_executor<Executor>::value ||
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                        net::is_executor<Executor>::value,
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                        net::execution::is_executor<Executor>::value ||
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                        net::is_executor<Executor>::value,
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
                         filesystem::path >::type & executable,
                 Args && args,
                 Inits && ... inits ) -> basic_process<Executor>

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

@@ -7,7 +7,12 @@
 
 #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>
@@ -19,6 +24,10 @@
 #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)
@@ -29,14 +38,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>
@@ -48,6 +57,10 @@ BOOST_PROCESS_V2_END_NAMESPACE
 #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
 
@@ -81,11 +94,6 @@ BOOST_PROCESS_V2_END_NAMESPACE
 #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
@@ -100,6 +108,9 @@ 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());   \
@@ -120,29 +131,31 @@ 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_DYN_LINK)
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROCESS_V2_DYN_LINK)
-#if defined(BOOST_PROCESS_SOURCE)
+#if defined(BOOST_PROCESS_V2_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,12 +69,7 @@ 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 has_x_access(const char * pth);
+BOOST_PROCESS_V2_DECL bool is_executable(const filesystem::path & pth, error_code & ec);
-
-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,15 +203,7 @@ 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 = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::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 &,
-                                    net::execution_context &>::value>::type * = nullptr)
+                                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value>::type * = nullptr)
             : pid_(-1), descriptor_(context)
     {
     }
@@ -275,27 +275,35 @@ 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;
-    net::posix::basic_stream_descriptor<Executor> descriptor_;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_stream_descriptor<Executor> descriptor_;
 
     struct async_wait_op_
     {
-        net::posix::basic_descriptor<Executor> &descriptor;
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::error::bad_descriptor;
+                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
             else 
             {
                 wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
@@ -306,7 +314,8 @@ struct basic_process_handle_fd
 
             if (!ec && (wait_res == 0))
             {
-                descriptor.async_wait(net::posix::descriptor_base::wait_read, std::move(self));
+                descriptor.async_wait(
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::descriptor_base::wait_read, std::move(self));
                 return;
             }
 
@@ -321,7 +330,8 @@ struct basic_process_handle_fd
                     self.complete(ec, code);
                 }
             };
-            net::post(descriptor.get_executor(), completer{ec, exit_code, std::move(self)});
+            BOOST_PROCESS_V2_ASIO_NAMESPACE::post(descriptor.get_executor(),
+                                                  completer{ec, exit_code, std::move(self)});
 
         }
 
@@ -335,18 +345,6 @@ 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 = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::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 &,
-                                                net::execution_context &>::value
+                                                BOOST_PROCESS_V2_ASIO_NAMESPACE::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 &,
-                                              net::execution_context &>::value
+                                              BOOST_PROCESS_V2_ASIO_NAMESPACE::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 &,
-                                              net::execution_context &>::value
+                                              BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
                                           >::type * = nullptr)
             : pid_(pid), descriptor_(context, process_handle)
     {
@@ -305,35 +305,37 @@ 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;
-    net::posix::basic_stream_descriptor<Executor> descriptor_;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_stream_descriptor<Executor> descriptor_;
-    net::basic_signal_set<Executor> signal_set_{descriptor_.get_executor(), SIGCHLD};
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> signal_set_{descriptor_.get_executor(), SIGCHLD};
 
     struct async_wait_op_
     {
-        net::posix::basic_descriptor<Executor> &descriptor;
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_descriptor<Executor> &descriptor;
-        net::basic_signal_set<Executor> &handle;
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> &handle;
         pid_type pid_;
         bool needs_post = true;
 
         template<typename Self>
-        void operator()(Self && self)
+        void operator()(Self &&self, error_code ec = {}, int = 0)
-        {
-          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 = net::error::bad_descriptor;
+                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
             else 
             {
                 wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
@@ -346,7 +348,7 @@ struct basic_process_handle_fd_or_signal
                 needs_post = false;
                 if (descriptor.is_open())
                     descriptor.async_wait(
-                            net::posix::descriptor_base::wait_read,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::descriptor_base::wait_read, 
                             std::move(self));
                 else
                     handle.async_wait(std::move(self));
@@ -368,22 +370,12 @@ struct basic_process_handle_fd_or_signal
             const auto exec = self.get_executor();
             completer cpl{ec, exit_code, std::move(self)};
             if (needs_post)
-                net::post(exec, std::move(cpl));
+                BOOST_PROCESS_V2_ASIO_NAMESPACE::post(exec, std::move(cpl));
             else
-                net::dispatch(exec, std::move(cpl));
+                BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::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 &,
-                                         net::execution_context &>::value
+                                         BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::basic_signal_set<Executor>;
+        using ss = BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor>;
         new (&signal_set_) ss(handle.get_executor(), SIGCHLD);
         handle.pid_ = -1;
         return *this;
@@ -269,21 +269,29 @@ 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;
-    net::basic_signal_set<Executor> signal_set_;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> signal_set_;
 
     struct async_wait_op_
     {
-        net::basic_signal_set<Executor> &handle;
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::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 
@@ -292,16 +300,16 @@ struct basic_process_handle_signal
         template<typename Self>
         void operator()(Self &&self, error_code ec, int sig)
         {
-            if (ec == net::error::operation_aborted &&
+            if (ec == BOOST_PROCESS_V2_ASIO_NAMESPACE::error::operation_aborted && 
                 self.get_cancellation_state().cancelled() 
-                    == net::cancellation_type::none)
+                    == BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_type::none)
                 ec.clear();
 
             native_exit_code_type exit_code = -1;
             int wait_res = -1;
 
             if (pid_ <= 0) // error, complete early
-                ec = net::error::bad_descriptor;
+                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
             else if (!ec)
             {
                 wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
@@ -328,19 +336,9 @@ struct basic_process_handle_signal
             };
 
             const auto exec = self.get_executor();
-            net::dispatch(exec, completer{ec, exit_code, std::move(self)});
+            BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
 struct basic_process_handle_win
 {
-    typedef net::windows::basic_object_handle<Executor> handle_type;
+    typedef BOOST_PROCESS_V2_ASIO_NAMESPACE::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 &,
-                                         net::execution_context &>::value
+                                         BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
                          >::type = 0)
             : pid_(0), handle_(context)
     {
@@ -266,6 +266,15 @@ 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:
@@ -279,17 +288,6 @@ 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));
         }
 
@@ -297,25 +295,11 @@ 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 = 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,7 +23,8 @@ 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> 
+         typename = typename std::enable_if<std::is_same<CharOut, CharIn>::value>::type>
+BOOST_PROCESS_V2_DECL 
 std::basic_string<CharOut, Traits, Allocator> conv_string(
     const CharIn * data, std::size_t size, 
     const Allocator allocator = Allocator{})
@@ -34,7 +35,8 @@ 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> 
+         typename = typename std::enable_if<std::is_same<CharOut, char>::value>::type>
+BOOST_PROCESS_V2_DECL 
 std::basic_string<CharOut, Traits, Allocator> conv_string(
     const wchar_t * data, std::size_t size, 
     const Allocator allocator = Allocator{})
@@ -57,7 +59,8 @@ 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> 
+         typename = typename std::enable_if<std::is_same<CharOut, wchar_t>::value>::type>
+BOOST_PROCESS_V2_DECL 
 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 = net::cancellation_type;
+        using cancellation_type = BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::enable_total_cancellation());
+        self.reset_cancellation_state(BOOST_PROCESS_V2_ASIO_NAMESPACE::enable_total_cancellation());
-        net::cancellation_slot s = self.get_cancellation_state().slot();
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_slot s = self.get_cancellation_state().slot();
         if (s.is_connected())
             s.emplace<cancel>(proc.get());
 
         auto pro_ = proc.get();
         pro_->async_wait(
-                net::bind_cancellation_slot(
+                BOOST_PROCESS_V2_ASIO_NAMESPACE::bind_cancellation_slot(
-                    net::cancellation_slot(),
+                    BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_slot(),
                     std::move(self)));
     }
 
@@ -101,18 +101,17 @@ 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 = net::any_io_executor,
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor,
         BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void (error_code, int))
-            WaitHandler = net::default_completion_token_t<Executor>>
+            WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
 inline
-auto async_execute(basic_process<Executor> proc,
+BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, int))
-                         WaitHandler && handler = net::default_completion_token_t<Executor>())
+async_execute(basic_process<Executor> proc,
-   -> decltype(net::async_compose<WaitHandler, void(error_code, int)>(
+                         WaitHandler && handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
-                  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 net::async_compose<WaitHandler, void(error_code, int)>(
+    return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, int)>(
             detail::execute_op<Executor>{std::move(pro_)}, handler, exec);
 }
 

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

@@ -8,7 +8,6 @@
 
 #include <string>
 #include <vector>
-#include <memory>
 
 #include <boost/process/v2/detail/config.hpp>
 #include <boost/process/v2/detail/throw_error.hpp>
@@ -37,7 +36,7 @@ BOOST_PROCESS_V2_DECL shell cmd(HANDLE handle);
 #endif
 
 template<typename Executor>
-inline shell cmd(basic_process_handle<Executor> & handle, error_code & ec)
+BOOST_PROCESS_V2_DECL shell cmd(basic_process_handle<Executor> & handle, error_code & ec)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
     return cmd(handle.native_handle(), ec);
@@ -47,7 +46,7 @@ inline shell cmd(basic_process_handle<Executor> & handle, error_code & ec)
 }
 
 template<typename Executor>
-inline shell cmd(basic_process_handle<Executor> & handle)
+BOOST_PROCESS_V2_DECL 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>
-inline filesystem::path cwd(basic_process_handle<Executor> & handle, error_code & ec)
+BOOST_PROCESS_V2_DECL 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 @@ inline filesystem::path cwd(basic_process_handle<Executor> & handle, error_code
 }
 
 template<typename Executor>
-inline filesystem::path cwd(basic_process_handle<Executor> & handle)
+BOOST_PROCESS_V2_DECL 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,7 +8,6 @@
 #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>
@@ -27,6 +26,9 @@ 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 *;
@@ -118,7 +120,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>
-inline env_view env(basic_process_handle<Executor> & handle, error_code & ec)
+BOOST_PROCESS_V2_DECL env_view env(basic_process_handle<Executor> & handle, error_code & ec)
 {
 #if defined(BOOST_PROCESS_V2_WINDOWS)
     return env(handle.native_handle(), ec);
@@ -128,7 +130,7 @@ inline env_view env(basic_process_handle<Executor> & handle, error_code & ec)
 }
 
 template<typename Executor>
-inline env_view env(basic_process_handle<Executor> & handle)
+BOOST_PROCESS_V2_DECL 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,7 +10,6 @@
 #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 = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::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&,
-                    net::execution_context&>::value, void *>::type = nullptr)
+                    BOOST_PROCESS_V2_ASIO_NAMESPACE::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&,
-                    net::execution_context&>::value,
+                    BOOST_PROCESS_V2_ASIO_NAMESPACE::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&,
-                    net::execution_context&>::value,
+                    BOOST_PROCESS_V2_ASIO_NAMESPACE::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&,
-                    net::execution_context&>::value,
+                    BOOST_PROCESS_V2_ASIO_NAMESPACE::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&,
-                    net::execution_context&>::value,
+                    BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::basic_writable_pipe<Executor>;
+    using stdin_type = BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_writable_pipe<Executor>;
     /// The type used for stdout on the parent process side.
-    using stdout_type = net::basic_readable_pipe<Executor>;
+    using stdout_type = BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_readable_pipe<Executor>;
 
     /// Get the stdin pipe.
     stdin_type  & get_stdin()  {return stdin_; }
@@ -336,11 +336,14 @@ struct basic_popen : basic_process<Executor>
      * std::vector.
      */
     template <typename ConstBufferSequence,
-            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, std::size_t))
+            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-            WriteToken = net::default_completion_token_t<executor_type>>
+                                                    std::size_t)) WriteToken
-    auto async_write_some(const ConstBufferSequence& buffers,
+            BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-                     WriteToken && token = net::default_completion_token_t<executor_type>())
+    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WriteToken,
-         -> decltype(std::declval<stdin_type&>().async_write_some(buffers, std::forward<WriteToken>(token)))
+                                       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))
     {
         return stdin_.async_write_some(buffers, std::forward<WriteToken>(token));
     }
@@ -448,12 +451,14 @@ struct basic_popen : basic_process<Executor>
      * std::vector.
      */
     template <typename MutableBufferSequence,
-            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, std::size_t))
+            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
-            ReadToken = net::default_completion_token_t<executor_type>>
+                                                    std::size_t)) ReadToken
-    auto async_read_some(const MutableBufferSequence& buffers,
+            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_MOVE_ARG(ReadToken) token
-                    = net::default_completion_token_t<executor_type>())
+                    BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(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(__APPLE__) || defined(__MACH__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__APPLE__) || defined(__MACH__)
 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&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -324,7 +324,7 @@ struct default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -335,8 +335,8 @@ struct default_launcher
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::query(
+            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                    exec, net::execution::context);
+                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-            ctx.notify_fork(net::execution_context::fork_prepare);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
             pid = ::fork();
             if (pid == -1)
             {
-                ctx.notify_fork(net::execution_context::fork_parent);
+                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::execution_context::fork_child);
+                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::execution_context::fork_parent);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -39,7 +39,7 @@ struct fork_and_forget_launcher : default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<is_convertible<
-                            ExecutionContext&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -50,8 +50,8 @@ struct fork_and_forget_launcher : default_launcher
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::query(
+            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                    exec, net::execution::context);
+                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-            ctx.notify_fork(net::execution_context::fork_prepare);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
             pid = ::fork();
             if (pid == -1)
             {
-                ctx.notify_fork(net::execution_context::fork_parent);
+                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::execution_context::fork_child);
+                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::execution_context::fork_parent);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -44,7 +44,7 @@ struct pdfork_launcher : default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<is_convertible<
-                            ExecutionContext&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -55,8 +55,8 @@ struct pdfork_launcher : default_launcher
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::query(
+            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                    exec, net::execution::context);
+                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-            ctx.notify_fork(net::execution_context::fork_prepare);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
             pid = ::pdfork(&fd, PD_DAEMON | PD_CLOEXEC);
             if (pid == -1)
             {
-                ctx.notify_fork(net::execution_context::fork_parent);
+                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::execution_context::fork_child);
+                ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::execution_context::fork_parent);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -41,7 +41,7 @@ struct vfork_launcher :  default_launcher
     auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<std::is_convertible<
-                            ExecutionContext&, net::execution_context&>::value,
+                            ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                             filesystem::path >::type & executable,
                     Args && args,
                     Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -52,8 +52,8 @@ struct vfork_launcher :  default_launcher
     template<typename Executor, typename Args, typename ... Inits>
     auto operator()(Executor exec,
                     const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                            net::execution::is_executor<Executor>::value ||
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::query(
+        auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
-                exec, net::execution::context);
+                exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
-        ctx.notify_fork(net::execution_context::fork_prepare);
+        ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
         pid = ::vfork();
         if (pid == -1)
         {
-            ctx.notify_fork(net::execution_context::fork_parent);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::execution_context::fork_parent);
+        ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::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 = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, 
-                              net::execution_context&>::value,
+                              BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, 
-                              net::execution_context&>::value,
+                              BOOST_PROCESS_V2_ASIO_NAMESPACE::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&,
-                                net::execution_context&>::value, void *>::type = nullptr)
+                                BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, 
-                                net::execution_context&>::value, void *>::type = nullptr)
+                                BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, 
-                                net::execution_context&>::value, void *>::type = nullptr)
+                                BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value, void *>::type = nullptr)
      : process_handle_(context.get_executor()) {}
 
 
@@ -325,7 +325,15 @@ 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>
@@ -355,7 +363,7 @@ private:
             }
         };
 
-        net::post(handle.get_executor(),
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::post(handle.get_executor(),
                                               completer{static_cast<int>(res), std::move(self)});
       }
       else
@@ -375,18 +383,6 @@ 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 = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
 struct basic_process_handle
 {
     /// The native handle of the process. 
@@ -123,26 +123,28 @@ 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 = net::default_completion_token_t<executor_type>>
+             WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
-    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<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));
+
 };
 
 
 #else
 #if defined(BOOST_PROCESS_V2_WINDOWS)
-template<typename Executor = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
 using basic_process_handle = detail::basic_process_handle_win<Executor>;
 #else
 
 #if defined(BOOST_PROCESS_V2_PIDFD_OPEN)
-template<typename Executor = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
 using basic_process_handle = detail::basic_process_handle_fd<Executor>;
 #elif defined(BOOST_PROCESS_V2_PDFORK)
-template<typename Executor = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
 using basic_process_handle = detail::basic_process_handle_fd_or_signal<Executor>;
 #else
 
-template<typename Executor = net::any_io_executor>
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::basic_readable_pipe<Executor> & pipe)
+  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_readable_pipe<Executor> & pipe)
   {
     if (Target == STD_INPUT_HANDLE)
     {
@@ -112,9 +112,9 @@ struct process_io_binding
       return ;
     }
 
-    net::detail::native_pipe_handle p[2];
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
     error_code ec;
-    net::detail::create_pipe(p, ec);
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::basic_writable_pipe<Executor> & pipe)
+  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::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 ;
     }
-    net::detail::native_pipe_handle p[2];
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
     error_code ec;
-    net::detail::create_pipe(p, ec);
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::basic_readable_pipe<Executor> & readable_pipe)
+  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_readable_pipe<Executor> & readable_pipe)
   {
     if (Target == STDIN_FILENO)
     {
@@ -189,15 +189,15 @@ struct process_io_binding
       return ;
     }
 
-    net::detail::native_pipe_handle p[2];
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
-    net::detail::create_pipe(p, ec);
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::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(net::basic_writable_pipe<Executor> & writable_pipe)
+  process_io_binding(BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_writable_pipe<Executor> & writable_pipe)
   {
 
     if (Target != STDIN_FILENO)
@@ -214,16 +214,16 @@ struct process_io_binding
       fd = writable_pipe.native_handle();
       return ;
     }
-    net::detail::native_pipe_handle p[2];
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
     error_code ec;
-    net::detail::create_pipe(p, ec);
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                              filesystem::path >::type & executable,
                   Args && args,
                   Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -47,7 +47,7 @@ struct as_user_launcher : default_launcher
   auto operator()(ExecutionContext & context,
                      error_code & ec,
                      const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context&>::value,
                              filesystem::path >::type & executable,
                      Args && args,
                      Inits && ... inits ) -> basic_process<typename ExecutionContext::executor_type>
@@ -58,8 +58,8 @@ struct as_user_launcher : default_launcher
   template<typename Executor, typename Args, typename ... Inits>
   auto operator()(Executor exec,
                      const typename std::enable_if<
-                             net::execution::is_executor<Executor>::value ||
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                      net::execution::is_executor<Executor>::value ||
+                      BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                      net::is_executor<Executor>::value,
+                      BOOST_PROCESS_V2_ASIO_NAMESPACE::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)

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&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                             net::execution::is_executor<Executor>::value
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value 
-                          || net::is_executor<Executor>::value,
+                          || BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                             net::execution::is_executor<Executor>::value ||
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                             net::execution::is_executor<Executor>::value ||
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                             net::execution::is_executor<Executor>::value ||
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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&, net::execution_context&>::value,
+                             ExecutionContext&, BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                             net::execution::is_executor<Executor>::value ||
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::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<
-                             net::execution::is_executor<Executor>::value ||
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value || 
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::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,10 +65,9 @@ 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 (::access(pth, X_OK) == 0);
+    return filesystem::is_regular_file(p, ec) && (::access(p.c_str(), 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_exec_type(const wchar_t * pth)
+bool is_executable(const filesystem::path & pth, error_code & ec)
 {
-    return SHGetFileInfoW(pth, 0,0,0, SHGFI_EXETYPE);
+    return filesystem::is_regular_file(pth, ec) && SHGetFileInfoW(pth.native().c_str(), 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,12 +23,9 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
+#include <sys/proc_info.h>
-#if !TARGET_OS_IOS
+#include <sys/sysctl.h>
-  #include <sys/proc_info.h>
+#include <libproc.h>
-  #include <sys/sysctl.h>
-  #include <libproc.h>
-#endif
 #endif
 
 #if (defined(__linux__) || defined(__ANDROID__))
@@ -52,7 +49,6 @@
 #endif
 
 #if defined(__sun)
-#include <cstdlib>
 #include <sys/types.h>
 #include <kvm.h>
 #include <sys/param.h>
@@ -160,7 +156,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
 }
     
-#elif (defined(__APPLE__) && defined(__MACH__)) && !TARGET_OS_IOS
+#elif (defined(__APPLE__) && defined(__MACH__))
 
 shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -169,7 +165,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 {};
     }
 
@@ -182,7 +178,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 {};
     }
 
@@ -199,7 +195,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;
@@ -224,7 +220,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 {};
         }
@@ -255,7 +251,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;
@@ -275,7 +271,6 @@ 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)
@@ -285,17 +280,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 {};
 }
     
@@ -303,9 +298,10 @@ 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)
@@ -316,24 +312,25 @@ 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 {};}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return vec;}
     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);
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
-    return {};
+    return vec;
 }
     
 #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;
 
@@ -346,17 +343,18 @@ 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 {};}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return vec;}
     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);
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    kvm_close(kd);
     return {};
 }
     
@@ -367,47 +365,36 @@ 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);
-    struct closer
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return {};}
+    if ((proc_info = kvm_getproc(kd, pid))) 
     {
-        void operator()(kvm_t * kd)
+        if ((proc_user = kvm_getu(kd, proc_info))) 
         {
-            kvm_close(kd);
+            if (!kvm_getcmd(kd, proc_info, proc_user, &cmd, 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); 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);})
             }
             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);
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    
+    kvm_close(kd);
     return {};
 }
 
 #else
-filesystem::path cmd(boost::process::v2::pid_type, boost::system::error_code & ec)
+#error "Platform not supported"
-{
-  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
-  return "";
-}
 #endif
 
 shell cmd(boost::process::v2::pid_type pid)

src/ext/cwd.cpp

@@ -24,11 +24,8 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
+#include <sys/proc_info.h>
-#if !TARGET_OS_IOS
+#include <libproc.h>
-  #include <sys/proc_info.h>
-  #include <libproc.h>
-#endif
 #endif
 
 #if (defined(BOOST_PROCESS_V2_WINDOWS) || defined(__linux__) || defined(__ANDROID__) || defined(__sun))
@@ -49,10 +46,8 @@
 #endif
 
 #if defined(__DragonFly__)
-#include <climits>
 #include <cstring>
-#include <sys/types.h>
+#include <cstdio>
-#include <sys/sysctl.h>
 #endif
 
 #ifdef BOOST_PROCESS_USE_STD_FS
@@ -73,7 +68,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 "";
 }
 
@@ -88,7 +83,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 {};
@@ -103,7 +98,7 @@ filesystem::path cwd(HANDLE proc)
     return res;
 }
 
-#elif (defined(__APPLE__) && defined(__MACH__)) && !TARGET_OS_IOS
+#elif (defined(__APPLE__) && defined(__MACH__))
 
 filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -111,7 +106,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 "";
 }
 
@@ -146,10 +141,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;
 }
 
@@ -157,16 +152,55 @@ 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;
-    char buffer[PATH_MAX];
+    // Official API (broken OS-level) - including code from DragonFly's fstat(1) 
-    std::size_t sz = 4, len = sizeof(buffer);
+    // command line interface utility currently requires way too much code FWIW.
+    std::size_t sz = 4, len = 0;
     int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_CWD, pid};
-    if (sysctl(mib, sz, buffer, &len, nullptr, 0) == 0)
+    if (sysctl(mib, sz, nullptr, &len, nullptr, 0) == 0)
     {
-        path = filesystem::canonical(buffer, ec);
+        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)
+    }
     else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        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)
     return path;
 }
 
@@ -187,24 +221,20 @@ filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code
     {
         std::vector<char> vecbuff;
         vecbuff.resize(len);
-        if (sysctl(mib, sz, &vecbuff[0], &len, nullptr, 0) == 0)
+        if (sysctl(mib, 4, &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
-filesystem::path cwd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+#error "Platform not supported"
-{
-  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,13 +21,9 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
+#include <sys/proc_info.h>
-#if !TARGET_OS_IOS
+#include <sys/sysctl.h>
-  #include <algorithm>
+#include <libproc.h>
-  #include <sys/proc_info.h>
-  #include <sys/sysctl.h>
-  #include <libproc.h>
-#endif
 #endif
 
 #if (defined(__linux__) || defined(__ANDROID__))
@@ -35,50 +31,12 @@
 #endif
 
 #if defined(__FreeBSD__)
-#include <algorithm>
+#include <sys/socket.h>
-#include <cstring>
-#include <fcntl.h>
-#include <kvm.h>
-#include <sys/param.h>
 #include <sys/sysctl.h>
+#include <sys/param.h>
+#include <sys/queue.h>
 #include <sys/user.h>
-#endif
+#include <libprocstat.h>
-
-#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
@@ -137,7 +95,7 @@ const environment::char_type * dereference(native_env_iterator iterator)
     return iterator;
 }
 
-#elif (defined(__APPLE___) || defined(__MACH__)) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun)
+#elif (defined(__APPLE___) || defined(__MACH__))
 
 void native_env_handle_deleter::operator()(native_env_handle_type h) const
 {
@@ -162,6 +120,31 @@ 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
 
 }
@@ -188,19 +171,19 @@ env_view env(HANDLE proc, boost::system::error_code & ec)
 
     if (error)
     {
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, system_category());
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, boost::system::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 {};
     }
 
@@ -211,7 +194,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 {};
     }
 
@@ -239,14 +222,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__)) && !TARGET_OS_IOS
+#elif (defined(__APPLE___) || defined(__MACH__))
 
 env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -255,7 +238,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 {};
     }
 
@@ -268,7 +251,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;
@@ -326,7 +309,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 {};
         }
@@ -345,175 +328,69 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     return ev;
 }
 
-#elif defined(__FreeBSD__) || defined(__DragonFly__)
+#elif defined(__FreeBSD__)
 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;
-  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 {};}
-  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++) 
-      {
-        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(__NetBSD__)
+  unsigned cntp = 0;
-env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+  procstat *proc_stat = procstat_open_sysctl();
-{
+  if (proc_stat != nullptr)
-  std::vector<char> vec;
-  int cntp = 0;
-  kinfo_proc2 *proc_info = nullptr;
-
-  struct closer
   {
-    void operator()(kvm_t * kd)
+    kinfo_proc *proc_info = procstat_getprocs(proc_stat, KERN_PROC_PID, pid, &cntp);
+    if (proc_info != nullptr)
     {
-      kvm_close(kd);
+      char **env = procstat_getenvv(proc_stat, proc_info, 0);
-    }
+      if (env != nullptr)
-  };
-
-  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++)
+        auto e = env;
-          vec.push_back(env[i][j]);
+        std::size_t n = 0u, len = 0u;
-        vec.push_back('\0');
+        while (e && *e != nullptr)
-      }
-      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++)
+          n ++;
-            vec.push_back(env[i][j]);
+          len += std::strlen(*e);
-          vec.push_back('\0');
+          e++;
         }
-        vec.push_back('\0');
+        std::size_t mem_needed =
-        free(env);
+            // 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)
+
       }
-      else
+      procstat_freeprocs(proc_stat, proc_info);
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
     }
     else
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    procstat_close(proc_stat);
   }
   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;
 }
+
 #endif
 
 env_view env(boost::process::v2::pid_type pid)

src/ext/exe.cpp

@@ -25,11 +25,8 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
+#include <sys/proc_info.h>
-#if !TARGET_OS_IOS
+#include <libproc.h>
-  #include <sys/proc_info.h>
-  #include <libproc.h>
-#endif
 #endif
 
 #if (defined(BOOST_PROCESS_V2_WINDOWS) || defined(__linux__) || defined(__ANDROID__) || defined(__sun))
@@ -39,7 +36,7 @@
 #if (defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__))
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
+#if !defined(__FreeBSD__)
 #include <alloca.h>
 #endif
 #endif
@@ -83,7 +80,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 "";
 }
@@ -109,14 +106,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__)) && !TARGET_OS_IOS
+#elif (defined(__APPLE__) && defined(__MACH__))
 
 filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
@@ -125,7 +122,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 "";
 }
 
@@ -165,7 +162,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 "";
 }
 
@@ -173,16 +170,12 @@ 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, system_category());
+    BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, boost::system::system_category())
     return "";
 }
 
 #else
-filesystem::path exe(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+#error "Platform not supported"
-{
-  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,6 +16,14 @@
 
 #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
@@ -43,19 +51,19 @@ std::wstring cwd_cmd_from_proc(HANDLE proc, int type, boost::system::error_code
 
     if (error)
     {
-        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, system_category());
+        BOOST_PROCESS_V2_ASSIGN_EC(ec, error, boost::system::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 {};
     }
 
@@ -74,7 +82,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 {};
     }
 
@@ -107,7 +115,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,11 +17,8 @@
 #endif
 
 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
+#include <sys/proc_info.h>
-#if !TARGET_OS_IOS
+#include <libproc.h>
-  #include <sys/proc_info.h>
-  #include <libproc.h>
-#endif
 #endif
 
 #if (defined(__linux__) || defined(__ANDROID__))
@@ -29,11 +26,10 @@
 #endif
 
 #if defined(__FreeBSD__)
-#include <fcntl.h>
+#include <sys/types.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__))
@@ -75,7 +71,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;
@@ -97,7 +93,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;
@@ -124,7 +120,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;
@@ -144,7 +140,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     return vec;
 }
 
-#elif (defined(__APPLE__) && defined(__MACH__)) && !TARGET_OS_IOS
+#elif (defined(__APPLE__) && defined(__MACH__))
 
 std::vector<pid_type> all_pids(boost::system::error_code & ec)
 {
@@ -153,7 +149,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);
@@ -166,7 +162,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
@@ -181,7 +177,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);
@@ -196,7 +192,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;
@@ -219,9 +215,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
@@ -246,7 +242,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;
             }
         }
@@ -278,89 +274,39 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
 {
     std::vector<pid_type> vec;
     int cntp = 0;
-    kinfo_proc *proc_info = nullptr;
+    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
-    const char *nlistf, *memf;
+    if (proc_info) 
-    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);
-    int cntp = 0;
+    kinfo_proc *proc_info = kinfo_getproc(pid);
-    kinfo_proc *proc_info = nullptr;
+    if (proc_info)
-    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;
+    int cntp = 0; 
-    kinfo_proc *proc_info = nullptr;
+    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
-    const char *nlistf, *memf;
+    if (proc_info)
-    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++)
@@ -370,9 +316,10 @@ 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;
 }
 
@@ -385,7 +332,6 @@ 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)
@@ -397,7 +343,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))) 
@@ -408,7 +354,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;
 }
 
@@ -419,7 +365,6 @@ 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)
@@ -431,7 +376,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)))
@@ -442,7 +387,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;
 }
 
@@ -453,7 +398,6 @@ 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)
@@ -465,7 +409,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)))
@@ -480,7 +424,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;
 }
 
@@ -491,7 +435,6 @@ 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)
@@ -503,7 +446,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)))
@@ -515,7 +458,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;
 }
 
@@ -524,7 +467,6 @@ 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)
@@ -536,7 +478,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)))
@@ -544,7 +486,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;
 }
 
@@ -553,7 +495,6 @@ 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)
@@ -565,7 +506,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)))
@@ -580,7 +521,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;
 }
 
@@ -591,7 +532,6 @@ 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)
@@ -603,7 +543,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)))
@@ -611,14 +551,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].p_pid >= 0)
+            if (proc_info[i].kp_pid >= 0) 
             {
-                vec.push_back(proc_info[i].p_pid);
+                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;
 }
 
@@ -627,7 +567,6 @@ 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)
@@ -639,7 +578,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)))
@@ -647,7 +586,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;
 }
 
@@ -656,7 +595,6 @@ 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)
@@ -668,7 +606,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)))
@@ -683,7 +621,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;
 }
 
@@ -695,7 +633,6 @@ 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)
@@ -707,7 +644,7 @@ 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)))
@@ -718,7 +655,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)
             break;
         }
     }
@@ -729,7 +666,6 @@ 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)
@@ -741,7 +677,7 @@ 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)))
@@ -749,7 +685,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;
 }
 
@@ -758,7 +694,6 @@ 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)
@@ -770,7 +705,7 @@ 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);
     if (!kd)
     {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
         return vec;
     }
     while ((proc_info = kvm_nextproc(kd)))
@@ -783,7 +718,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)
                 break;
             }
         }
@@ -792,21 +727,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
 }
 
 #else
-std::vector<pid_type> all_pids(boost::system::error_code & ec)
+#error "Platform not supported"
-{
-  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,9 +17,10 @@
 // linux has close_range since 5.19
 
 
-#if defined(__FreeBSD__)
+#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 
 // 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
@@ -44,8 +45,7 @@ int fdwalk(int (*func)(void *, int), void *cd);
 
 #include <linux/version.h>
 
-// kernel has close_range
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0) // kernel has close_range
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0) && !defined(BOOST_PROCESS_V2_POSIX_FORCE_DISABLE_CLOSE_RANGE)
 
 // version is included by stdlib.h #include <gnu/libc-version.h>
 #if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 34) // glibc is compiled with close_range support
@@ -219,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>
-#elif !defined(__OpenBSD__)
+#else
 #include <wordexp.h>
 #endif
 
@@ -30,7 +30,7 @@ BOOST_PROCESS_V2_DECL const error_category& get_shell_category()
 {
     return system_category();
 }
-#elif !defined(__OpenBSD__)
+#else
 
 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.shell";
+        return "process.v2.utf8";
     }
     std::string message(int value) const
     {
@@ -66,13 +66,6 @@ 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)
@@ -99,7 +92,7 @@ auto shell::args() const-> args_type
     return input_.c_str();
 }
 
-#elif !defined(__OpenBSD__)
+#else
 
 void shell::parse_()
 {
@@ -142,22 +135,6 @@ 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,23 +9,25 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 
-lib ws2_32 ;
+import os ;
-lib shell32 ;
+
-lib Advapi32 ;
+if [ os.name ] = NT
-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
 ;
 
 
@@ -33,18 +35,16 @@ project : requirements
 import testing ;
 
 
-alias program_options  : usage-requirements <library>/boost/program_options//boost_program_options ;
+alias program_options  : /boost//program_options : <link>static ;
-alias filesystem       : usage-requirements <library>/boost/filesystem//boost_filesystem ;
+alias filesystem       : /boost//filesystem      ;
-alias iostreams        : usage-requirements <library>/boost/iostreams//boost_iostreams ;
+alias iostreams        : /boost//iostreams       ;
-alias system           : usage-requirements <library>/boost/system//boost_system ;
+alias system           : /boost//system          ;
-alias thread           : usage-requirements <library>/boost/thread//boost_thread ;
+alias thread           : /boost//thread          ;
-alias scope_exit       : usage-requirements <library>/boost/scope_exit//boost_scope_exit ;
+alias coroutine        : /boost//coroutine       : <link>static ;
-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 lambda :
+exe sparring_partner : sparring_partner.cpp program_options system filesystem iostreams :
     <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 scope_exit  : [ test-options group_wait ] : sparring_partner : <target-os>darwin:<build>no <target-os>freebsd:<build>no ]
+    [ run group_wait.cpp     system thread filesystem         : [ 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 chrono           : [ test-options system_test1 ] : sparring_partner ]
+    [ run system_test1.cpp filesystem system                  : [ test-options system_test1 ] : sparring_partner ]
-    [ run system_test2.cpp filesystem system chrono           : [ test-options system_test2 ] : sparring_partner ]
+    [ run system_test2.cpp filesystem system                  : [ 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,10 +123,13 @@ test-suite with-valgrind :
    : <dependency>bare ;
 
 test-suite without-valgrind :
-    [ run async_system_future.cpp filesystem system                     : [ test-options async_system_future ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+    [ 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_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_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 async_system_stackless.cpp filesystem system coroutine        : [ 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/steady_timer.hpp>
+#include <boost/asio/deadline_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::steady_timer timeout{io_context, std::chrono::seconds(2)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(3)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout1{io_context1, std::chrono::seconds(2)};
+    boost::asio::deadline_timer timeout1{io_context1, boost::posix_time::seconds(2)};
     timeout1.async_wait([&](boost::system::error_code ec){if (!ec) io_context1.stop();});
 
-    boost::asio::steady_timer timeout2{io_context2, std::chrono::seconds(7)};
+    boost::asio::deadline_timer timeout2{io_context2, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(5)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(2)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(2)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(2)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(2)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(2)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::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::steady_timer timeout{io_context, std::chrono::seconds(3)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(3)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
 
@@ -148,17 +148,12 @@ 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", "121",
+            "test", "--exit-code", "221",
             ec,
             bp::on_exit=[](int exit_code, std::error_code) mutable {},
             io_context
     );
     BOOST_REQUIRE(!ec);
-    while (c.running())
+    io_context.run_for(std::chrono::milliseconds(100));
-    {
+    BOOST_CHECK_EQUAL(221, c.exit_code());
-      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/steady_timer.hpp>
+#include <boost/asio/deadline_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::steady_timer timeout{io_context, std::chrono::seconds(3)};
+    boost::asio::deadline_timer timeout{io_context, boost::posix_time::seconds(3)};
     timeout.async_wait([&](boost::system::error_code ec){if (!ec) io_context.stop();});
 
 

test/v2/Jamfile.jam

@@ -4,15 +4,19 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 
-lib ws2_32 ;
+import os ;
-lib shell32 ;
+
-lib Advapi32 ;
+if [ os.name ] = NT
-lib Ntdll ;
+{
-lib user32 ;
+  lib ws2_32 ;
-lib Bcrypt ;
+  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
@@ -20,44 +24,42 @@ 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>-lpthread
+  <target-os>freebsd:<linkflags>-lutil
   <target-os>freebsd:<linkflags>-lkvm
-  <target-os>bsd:<linkflags>-lpthread
+  <target-os>freebsd:<linkflags>-lprocstat
   <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
-
     ;
 
-local test_impl = test_impl.cpp /boost/process//boost_process /boost/test//boost_unit_test_framework ;
+lib test_impl : test_impl.cpp filesystem /boost//process :
+        <define>BOOST_PROCESS_V2_SEPARATE_COMPILATION=1
+        <define>BOOST_TEST_IGNORE_SIGCHLD=1
+        <link>static
+        ;
 
 test-suite standalone :
-    [ run utf8.cpp        $(test_impl) ]
+    [ run utf8.cpp test_impl ]
-    [ run cstring_ref.cpp $(test_impl) ]
+    [ run cstring_ref.cpp test_impl ]
-    [ run environment.cpp $(test_impl) ]
+    [ run environment.cpp test_impl ]
-    [ run shell.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 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 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 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 ext.cpp     test_impl : --log_level=all --catch_system_errors=no -- : target : <target-os>darwin:<build>no ]
     ;
 

test/v2/process.cpp

@@ -9,6 +9,9 @@
 #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)
@@ -31,7 +34,6 @@
 #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>
@@ -53,9 +55,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"};
@@ -83,7 +85,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"});
@@ -198,7 +200,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};
@@ -294,7 +296,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};
@@ -474,7 +476,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);
@@ -509,7 +511,7 @@ BOOST_AUTO_TEST_CASE(exit_code_as_error)
   bpv::process proc3(ctx, pth, {"sleep", "2000"});
 
   int called = 0;
-
+  
   proc3.terminate();
 
 
@@ -640,30 +642,6 @@ 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/unit_test.hpp>
+#include <boost/test/included/unit_test.hpp>

test/v2/windows.cpp

@@ -9,6 +9,10 @@
 #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>