b2 link fixes.

c++14 constexpr fixes for environment_win.
2026-01-20 04:42:24 +00:00 · 2024-07-12 07:52:51 +08:00 · 2024-07-12 07:42:52 +08:00
60 changed files with 737 additions and 1080 deletions
--- a/.drone.star
+++ b/.drone.star
@@ -14,8 +14,8 @@ windowsglobalimage="cppalliance/dronevs2019"

 def main(ctx):
  return [
-  freebsd_cxx("gcc freebsd", "g++", buildtype="boost", buildscript="drone", freebsd_version="13.1", environment={'B2_TOOLSET': 'gcc', 'B2_CXXSTD': '11'}, globalenv=globalenv),
-  freebsd_cxx("clang 14 freebsd", "clang++-14", buildtype="boost", buildscript="drone", freebsd_version="13.1", environment={'B2_TOOLSET': 'clang-14', 'B2_CXXSTD': '11'}, globalenv=globalenv),
+  freebsd_cxx("gcc 11 freebsd", "g++-11", buildtype="boost", buildscript="drone", freebsd_version="13.1", environment={'B2_TOOLSET': 'gcc-11', 'B2_CXXSTD': '17,20', 'B2_LINKFLAGS': '-Wl,-rpath=/usr/local/lib/gcc11'}, globalenv=globalenv),
+  freebsd_cxx("clang 14 freebsd", "clang++-14", buildtype="boost", buildscript="drone", freebsd_version="13.1", environment={'B2_TOOLSET': 'clang-14', 'B2_CXXSTD': '17,20'}, globalenv=globalenv),
  linux_cxx("docs", "", packages="docbook docbook-xml docbook-xsl xsltproc libsaxonhe-java default-jre-headless flex libfl-dev bison unzip rsync", image="cppalliance/droneubuntu1804:1", buildtype="docs", buildscript="drone", environment={"COMMENT": "docs"}, globalenv=globalenv),
  linux_cxx("asan",         "g++-8",  packages="g++-8",  buildtype="boost", buildscript="drone", image=linuxglobalimage,                        environment={'COMMENT': 'asan',  'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8',  'B2_CXXSTD': '11', 'B2_ASAN':  '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'DRONE_EXTRA_PRIVILEGED': 'True', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv, privileged=True),
  linux_cxx("ubsan",        "g++-8",  packages="g++-8",  buildtype="boost", buildscript="drone", image=linuxglobalimage,                        environment={'COMMENT': 'ubsan', 'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8',  'B2_CXXSTD': '11', 'B2_UBSAN': '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'B2_LINKFLAGS': '-fuse-ld=gold',  'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -141,43 +141,6 @@ jobs:
          cd ../boost-root
          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release

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

 import os ;
 import feature ;
-import-search /boost/config/checks ;
-import config : requires ;
+import ../../config/checks/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 ;
-lib advapi32 ;
-lib ntdll ;
-lib user32 ;
-lib ws2_32 ;
-
-lib kvm ;
-lib procstat ;
+if [ os.name ] = NT
+{
+  lib shell32 ;
+  lib Advapi32 ;
+  lib Ntdll ;
+  lib user32 ;
+}

 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.disable-close-range>on:<define>BOOST_PROCESS_V2_POSIX_FORCE_DISABLE_CLOSE_RANGE=1
+     <boost.process.fs>boost:<library>/boost//filesystem
     <target-os>windows:<library>shell32
     <target-os>windows:<library>user32
-     <target-os>windows:<library>ntdll
-     <target-os>windows:<library>advapi32
-     <target-os>windows:<library>ws2_32
-     <target-os>bsd:<library>kvm
-     <target-os>freebsd:<library>kvm
-     <target-os>freebsd:<library>procstat
-     <target-os>netbsd:<library>kvm
-     <target-os>openbsd:<library>kvm
-     <target-os>solaris:<library>kvm
+     <target-os>windows:<library>Ntdll
+     <target-os>windows:<library>Advapi32
   : 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 ;
--- a/doc/Jamfile.jam
+++ b/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 ;
--- a/doc/process.qbk
+++ b/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]
--- a/doc/v1.qbk
+++ b/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]
--- a/doc/v2/introduction.qbk
+++ b/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),
--- a/example/Jamfile.jam
+++ b/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
 ;
--- a/example/v2/Jamfile.jam
+++ b/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 ;
-exe intro_popen : intro_popen.cpp : <boost.process.fs>boost ;
+alias filesystem   : /boost//filesystem : <link>static ;
+
+exe intro : intro.cpp filesystem ;
+exe intro_popen : intro_popen.cpp filesystem ;
--- a/include/boost/process/v1/pipe.hpp
+++ b/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());
-          _pipe.close();
-          return this;
-        }
-        catch(...)
-        {
-          _pipe.close();
-          throw ;
-        }
+        overflow(Traits::eof());
        return this;
    }
 private:
--- a/include/boost/process/v2/bind_launcher.hpp
+++ b/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 ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                        net::is_executor<Executor>::value,
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                        net::is_executor<Executor>::value,
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::is_executor<Executor>::value ||
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::is_executor<Executor>::value,
                        filesystem::path >::type & executable,
                Args && args,
                Inits && ... inits ) -> basic_process<Executor>
--- a/include/boost/process/v2/detail/config.hpp
+++ b/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_PROCESS_SOURCE)
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROCESS_V2_DYN_LINK)
+#if defined(BOOST_PROCESS_V2_SOURCE)
 #define BOOST_PROCESS_V2_DECL BOOST_SYMBOL_EXPORT
 #else
 #define BOOST_PROCESS_V2_DECL BOOST_SYMBOL_IMPORT
@@ -163,7 +176,7 @@ BOOST_PROCESS_V2_END_NAMESPACE
 #endif
 #endif

-#if defined(__FreeBSD__) && !defined(BOOST_PROCESS_V2_DISABLE_PDFORK)
+#if defined(__FreeBSD__) && defined(BOOST_PROCESS_V2_ENABLE_PDFORK)
 #define BOOST_PROCESS_V2_PDFORK 1
 #define BOOST_PROCESS_V2_HAS_PROCESS_HANDLE 1
 #endif
--- a/include/boost/process/v2/detail/environment_posix.hpp
+++ b/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);
-
-inline bool is_executable(const filesystem::path & pth, error_code & ec)
-{
-  return filesystem::is_regular_file(pth, ec) && has_x_access(pth.c_str());
-}
+BOOST_PROCESS_V2_DECL bool is_executable(const filesystem::path & pth, error_code & ec);

 }

--- a/include/boost/process/v2/detail/environment_win.hpp
+++ b/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_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());
-}
-
+BOOST_PROCESS_V2_DECL bool is_executable(const filesystem::path & pth, error_code & ec);
 }

 }
--- a/include/boost/process/v2/detail/process_handle_fd.hpp
+++ b/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_);
-    }
-
 };
 }

--- a/include/boost/process/v2/detail/process_handle_fd_or_signal.hpp
+++ b/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,39 +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_;
-    net::basic_signal_set<Executor> signal_set_{descriptor_.get_executor(), SIGCHLD};
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_stream_descriptor<Executor> descriptor_;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> signal_set_{descriptor_.get_executor(), SIGCHLD};

    struct async_wait_op_
    {
-        net::posix::basic_stream_descriptor<Executor> &descriptor;
-        net::basic_signal_set<Executor> &handle;
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_descriptor<Executor> &descriptor;
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> &handle;
        pid_type pid_;
-        async_wait_op_(net::posix::basic_stream_descriptor<Executor> &descriptor,
-                       net::basic_signal_set<Executor> &handle,
-                        pid_type pid_) : descriptor(descriptor), handle(handle), pid_(pid_) {}
-
        bool needs_post = true;

        template<typename Self>
-        void operator()(Self && self)
-        {
-          self.reset_cancellation_state(asio::enable_total_cancellation());
-          (*this)(std::move(self), error_code{});
-        }
-
-        template<typename Self>
-        void operator()(Self &&self, error_code ec, int = 0)
+        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);
@@ -347,11 +345,10 @@ struct basic_process_handle_fd_or_signal

            if (!ec && (wait_res == 0))
            {
-                static char dummy[128];
                needs_post = false;
                if (descriptor.is_open())
-                    descriptor.async_read_some(
-                            asio::buffer(dummy),
+                    descriptor.async_wait(
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::descriptor_base::wait_read, 
                            std::move(self));
                else
                    handle.async_wait(std::move(self));
@@ -373,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_);
-    }
 };
 }

--- a/include/boost/process/v2/detail/process_handle_signal.hpp
+++ b/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_);
-    }
 };

 }
--- a/include/boost/process/v2/detail/process_handle_windows.hpp
+++ b/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<>;
--- a/include/boost/process/v2/detail/utf8.hpp
+++ b/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{})
--- a/include/boost/process/v2/environment.hpp
+++ b/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;
    }

--- a/include/boost/process/v2/execute.hpp
+++ b/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());
-        net::cancellation_slot s = self.get_cancellation_state().slot();
+        self.reset_cancellation_state(BOOST_PROCESS_V2_ASIO_NAMESPACE::enable_total_cancellation());
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::cancellation_slot s = self.get_cancellation_state().slot();
        if (s.is_connected())
            s.emplace<cancel>(proc.get());

        auto pro_ = proc.get();
        pro_->async_wait(
-                net::bind_cancellation_slot(
-                    net::cancellation_slot(),
+                BOOST_PROCESS_V2_ASIO_NAMESPACE::bind_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,
-                         WaitHandler && handler = net::default_completion_token_t<Executor>())
-   -> decltype(net::async_compose<WaitHandler, void(error_code, int)>(
-                  detail::execute_op<Executor>{nullptr}, handler, std::declval<Executor>()))
+BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, int))
+async_execute(basic_process<Executor> proc,
+                         WaitHandler && handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
 {
    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);
 }

--- a/include/boost/process/v2/ext/cmd.hpp
+++ b/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());
--- a/include/boost/process/v2/ext/cwd.hpp
+++ b/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());
--- a/include/boost/process/v2/ext/env.hpp
+++ b/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());
--- a/include/boost/process/v2/pid.hpp
+++ b/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

--- a/include/boost/process/v2/popen.hpp
+++ b/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))
-            WriteToken = net::default_completion_token_t<executor_type>>
-    auto async_write_some(const ConstBufferSequence& buffers,
-                     WriteToken && token = net::default_completion_token_t<executor_type>())
-         -> decltype(std::declval<stdin_type&>().async_write_some(buffers, std::forward<WriteToken>(token)))
+            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+                                                    std::size_t)) WriteToken
+            BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WriteToken,
+                                       void (boost::system::error_code, std::size_t))
+    async_write_some(const ConstBufferSequence& buffers,
+                     BOOST_ASIO_MOVE_ARG(WriteToken) token
+                     BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
    {
        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))
-            ReadToken = net::default_completion_token_t<executor_type>>
-    auto async_read_some(const MutableBufferSequence& buffers,
+            BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code,
+                                                    std::size_t)) ReadToken
+            BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(ReadToken,
+                                       void (boost::system::error_code, std::size_t))
+    async_read_some(const MutableBufferSequence& buffers,
                    BOOST_ASIO_MOVE_ARG(ReadToken) token
-                    = net::default_completion_token_t<executor_type>())
-        -> decltype(std::declval<stdout_type&>().async_read_some(buffers, std::forward<ReadToken>(token)))
+                    BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
    {
        return stdout_.async_read_some(buffers, std::forward<ReadToken>(token));
    }
--- a/include/boost/process/v2/posix/default_launcher.hpp
+++ b/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,19 +324,19 @@ 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>
    {
-        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
    }

    template<typename Executor, typename Args, typename ... Inits>
    auto operator()(Executor exec,
                    const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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(
-                    exec, net::execution::context);
-            ctx.notify_fork(net::execution_context::fork_prepare);
+            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
+                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
            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)
            {
--- a/include/boost/process/v2/posix/fork_and_forget_launcher.hpp
+++ b/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,19 +39,19 @@ struct fork_and_forget_launcher : default_launcher
    auto operator()(ExecutionContext & context,
                    error_code & ec,
                    const typename std::enable_if<is_convertible<
-                            ExecutionContext&, 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>
    {
-        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
    }

    template<typename Executor, typename Args, typename ... Inits>
    auto operator()(Executor exec,
                    const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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(
-                    exec, net::execution::context);
-            ctx.notify_fork(net::execution_context::fork_prepare);
+            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
+                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
            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...);
--- a/include/boost/process/v2/posix/pdfork_launcher.hpp
+++ b/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,19 +44,19 @@ 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>
    {
-        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
    }

    template<typename Executor, typename Args, typename ... Inits>
    auto operator()(Executor exec,
                    const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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(
-                    exec, net::execution::context);
-            ctx.notify_fork(net::execution_context::fork_prepare);
+            auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
+                    exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
+            ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
            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)
            {
--- a/include/boost/process/v2/posix/vfork_launcher.hpp
+++ b/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,19 +41,19 @@ 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>
    {
-        return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+        return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
    }

    template<typename Executor, typename Args, typename ... Inits>
    auto operator()(Executor exec,
                    const typename std::enable_if<
-                            net::execution::is_executor<Executor>::value ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                            net::is_executor<Executor>::value,
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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(
-                exec, net::execution::context);
-        ctx.notify_fork(net::execution_context::fork_prepare);
+        auto & ctx = BOOST_PROCESS_V2_ASIO_NAMESPACE::query(
+                exec, BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::context);
+        ctx.notify_fork(BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context::fork_prepare);
        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)
        {
--- a/include/boost/process/v2/process.hpp
+++ b/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.
--- a/include/boost/process/v2/process_handle.hpp
+++ b/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>>
-    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<executor_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));
+
 };


 #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
--- a/include/boost/process/v2/stdio.hpp
+++ b/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];
-    net::detail::create_pipe(p, ec);
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::detail::native_pipe_handle p[2];
+    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;
--- a/include/boost/process/v2/windows/as_user_launcher.hpp
+++ b/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,19 +47,19 @@ struct as_user_launcher : default_launcher
  auto operator()(ExecutionContext & context,
                     error_code & ec,
                     const typename std::enable_if<std::is_convertible<
-                             ExecutionContext&, 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>
  {
-      return (*this)(context.get_executor(), ec, executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
+      return (*this)(context.get_executor(), executable, std::forward<Args>(args), std::forward<Inits>(inits)...);
  }

  template<typename Executor, typename Args, typename ... Inits>
  auto operator()(Executor exec,
                     const typename std::enable_if<
-                             net::execution::is_executor<Executor>::value ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                      net::is_executor<Executor>::value,
+                      BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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)
@@ -133,4 +133,4 @@ struct as_user_launcher : default_launcher
 }
 BOOST_PROCESS_V2_END_NAMESPACE

-#endif //  BOOST_PROCESS_V2_WINDOWS_AS_USER_LAUNCHER_HPP
+#endif //  BOOST_PROCESS_V2_WINDOWS_AS_USER_LAUNCHER_HPP
--- a/include/boost/process/v2/windows/default_launcher.hpp
+++ b/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
-                          || net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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)
--- a/include/boost/process/v2/windows/with_logon_launcher.hpp
+++ b/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 ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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)
--- a/include/boost/process/v2/windows/with_token_launcher.hpp
+++ b/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 ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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 ||
-                             net::is_executor<Executor>::value,
+                             BOOST_PROCESS_V2_ASIO_NAMESPACE::execution::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)
--- a/src/detail/environment_posix.cpp
+++ b/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 has_x_access(const char * pth)
+bool is_executable(const filesystem::path & p, error_code & ec)
 {
-  return (::access(pth, X_OK) == 0);
+    return filesystem::is_regular_file(p, ec) && (::access(p.c_str(), X_OK) == 0);
 }

 }
--- a/src/detail/environment_win.cpp
+++ b/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);
 }

 }
--- a/src/detail/process_handle_windows.cpp
+++ b/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

--- a/src/detail/utf8.cpp
+++ b/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;
 }
--- a/src/ext/cmd.cpp
+++ b/src/ext/cmd.cpp
@@ -23,12 +23,9 @@
 #endif

 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
-#if !TARGET_OS_IOS
-  #include <sys/proc_info.h>
-  #include <sys/sysctl.h>
-  #include <libproc.h>
-#endif
+#include <sys/proc_info.h>
+#include <sys/sysctl.h>
+#include <libproc.h>
 #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);
-    return {};
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+    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;
-
-    struct 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, pid))) 
    {
-        void operator()(kvm_t * kd)
+        if ((proc_user = kvm_getu(kd, proc_info))) 
        {
-            kvm_close(kd);
-        }
-    };
-
-    std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
-    if ((proc_info = kvm_getproc(kd.get(), pid))) 
-    {
-        if ((proc_user = kvm_getu(kd.get(), proc_info))) 
-        {
-            if (!kvm_getcmd(kd.get(), proc_info, proc_user, &cmd, nullptr)) 
+            if (!kvm_getcmd(kd, 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)
-{
-  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
-  return "";
-}
+#error "Platform not supported"
 #endif

 shell cmd(boost::process::v2::pid_type pid)
--- a/src/ext/cwd.cpp
+++ b/src/ext/cwd.cpp
@@ -24,11 +24,8 @@
 #endif

 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
-#if !TARGET_OS_IOS
-  #include <sys/proc_info.h>
-  #include <libproc.h>
-#endif
+#include <sys/proc_info.h>
+#include <libproc.h>
 #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 <sys/sysctl.h>
+#include <cstdio>
 #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];
-    std::size_t sz = 4, len = sizeof(buffer);
+    // Official API (broken OS-level) - including code from DragonFly's fstat(1) 
+    // command line interface utility currently requires way too much code FWIW.
+    std::size_t sz = 4, len = 0;
    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)
-{
-  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
-  return "";
-}
+#error "Platform not supported"
 #endif

 filesystem::path cwd(boost::process::v2::pid_type pid)
--- a/src/ext/env.cpp
+++ b/src/ext/env.cpp
@@ -21,13 +21,9 @@
 #endif

 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
-#if !TARGET_OS_IOS
-  #include <algorithm>
-  #include <sys/proc_info.h>
-  #include <sys/sysctl.h>
-  #include <libproc.h>
-#endif
+#include <sys/proc_info.h>
+#include <sys/sysctl.h>
+#include <libproc.h>
 #endif

 #if (defined(__linux__) || defined(__ANDROID__))
@@ -35,50 +31,12 @@
 #endif

 #if defined(__FreeBSD__)
-#include <algorithm>
-#include <cstring>
-#include <fcntl.h>
-#include <kvm.h>
-#include <sys/param.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
+#include <sys/param.h>
+#include <sys/queue.h>
 #include <sys/user.h>
-#endif
-
-#if defined(__DragonFly__)
-#include <algorithm>
-#include <cstring>
-#include <sys/types.h>
-#include <kvm.h>
-#endif
-
-#if defined(__NetBSD__)
-#include <algorithm>
-#include <cstring>
-#include <fcntl.h>
-#include <kvm.h>
-#include <sys/param.h>
-#include <sys/sysctl.h>
-#endif
-
-#if defined(__OpenBSD__)
-#include <algorithm>
-#include <cstring>
-#include <sys/param.h>
-#include <sys/sysctl.h>
-#include <fcntl.h>
-#include <kvm.h>
-#endif
-
-#if defined(__sun)
-#include <algorithm>
-#include <cstdlib>
-#include <cstring>
-#include <kvm.h>
-#include <fcntl.h>
-#include <sys/param.h>
-#include <sys/time.h>
-#include <sys/user.h>
-#include <sys/proc.h>
+#include <libprocstat.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__)
-env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
-{
-  std::vector<char> vec;
-  int cntp = 0;
-  kinfo_proc2 *proc_info = nullptr;
-
-  struct closer
+  unsigned cntp = 0;
+  procstat *proc_stat = procstat_open_sysctl();
+  if (proc_stat != nullptr)
  {
-    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);
-    }
-  };
-
-  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++) 
+      char **env = procstat_getenvv(proc_stat, proc_info, 0);
+      if (env != nullptr)
      {
-        for (int j = 0; j < strlen(env[i]); j++)
-          vec.push_back(env[i][j]);
-        vec.push_back('\0');
-      }
-      vec.push_back('\0');
-    }
-    else
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-  }
-  else
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-
-  env_view ev;
-  ev.handle_.reset(new char[vec.size()]());
-  std::copy(vec.begin(), vec.end(), ev.handle_.get());
-  return ev;
-}
-#elif defined(__OpenBSD__)
-env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
-{
-  std::vector<char> vec;
-  int cntp = 0;
-  kinfo_proc *proc_info = nullptr;
-
-  struct closer
-  {
-    void operator()(kvm_t * kd)
-    {
-      kvm_close(kd);
-    }
-  };
-
-  std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
-  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
-  if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc), &cntp)))
-  {
-    char **env = kvm_getenvv(kd.get(), proc_info, 0);
-    if (env)
-    {
-      for (int i = 0; env[i] != nullptr; i++) 
-      {
-        for (int j = 0; j < strlen(env[i]); j++)
-          vec.push_back(env[i][j]);
-        vec.push_back('\0');
-      }
-      vec.push_back('\0');
-    }
-    else
-      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-  }
-  else
-    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-
-  env_view ev;
-  ev.handle_.reset(new char[vec.size()]());
-  std::copy(vec.begin(), vec.end(), ev.handle_.get());
-  return ev;
-}
-#elif defined(__sun)
-env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
-{
-  std::vector<char> vec;
-  char **env = nullptr;
-  proc *proc_info = nullptr;
-  user *proc_user = nullptr;
-
-  struct closer
-  {
-    void operator()(kvm_t * kd)
-    {
-      kvm_close(kd);
-    }
-  };
-
-  std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
-  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
-  if ((proc_info = kvm_getproc(kd.get(), pid))) 
-  {
-    if ((proc_user = kvm_getu(kd.get(), proc_info))) 
-    {
-      if (!kvm_getcmd(kd.get(), proc_info, proc_user, nullptr, &env)) 
-      {
-        for (int i = 0; env[i] != nullptr; i++) 
+        auto e = env;
+        std::size_t n = 0u, len = 0u;
+        while (e && *e != nullptr)
        {
-          for (int j = 0; j < strlen(env[i]); j++)
-            vec.push_back(env[i][j]);
-          vec.push_back('\0');
+          n ++;
+          len += std::strlen(*e);
+          e++;
        }
-        vec.push_back('\0');
-        free(env);
+        std::size_t mem_needed =
+            // environ         -  nullptr       - strlen  + null terminators
+            (n * sizeof(char*)) + sizeof(char*) + len     + n;
+
+        char * out = new (std::nothrow) char[mem_needed];
+        if (out != nullptr)
+        {
+          auto eno = reinterpret_cast<char**>(out);
+          auto eeo = eno;
+            auto str = out +  (n * sizeof(char*)) + sizeof(char*);
+          e = env;
+          while (*e != nullptr)
+          {
+            auto len = std::strlen(*e) + 1u;
+            std::memcpy(str, *e, len);
+            *eno = str;
+            str += len;
+            eno ++;
+            e++;
+          }
+          *eno = nullptr;
+
+          ev.handle_.reset(eeo);
+        }
+        else
+            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
+
      }
-      else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+      procstat_freeprocs(proc_stat, proc_info);
+
    }
    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);
-
-  env_view ev;
-  ev.handle_.reset(new char[vec.size()]());
-  std::copy(vec.begin(), vec.end(), ev.handle_.get());
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
  return ev;
 }
+
 #endif

 env_view env(boost::process::v2::pid_type pid)
--- a/src/ext/exe.cpp
+++ b/src/ext/exe.cpp
@@ -25,11 +25,8 @@
 #endif

 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
-#if !TARGET_OS_IOS
-  #include <sys/proc_info.h>
-  #include <libproc.h>
-#endif
+#include <sys/proc_info.h>
+#include <libproc.h>
 #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)
-{
-  BOOST_PROCESS_V2_ASSIGN_EC(ec, ENOTSUP, system_category());
-  return "";
-}
+#error "Platform not supported"
 #endif

 filesystem::path exe(boost::process::v2::pid_type pid)
--- a/src/ext/proc_info.cpp
+++ b/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
--- a/src/pid.cpp
+++ b/src/pid.cpp
@@ -17,11 +17,8 @@
 #endif

 #if (defined(__APPLE__) && defined(__MACH__))
-#include <TargetConditionals.h>
-#if !TARGET_OS_IOS
-  #include <sys/proc_info.h>
-  #include <libproc.h>
-#endif
+#include <sys/proc_info.h>
+#include <libproc.h>
 #endif

 #if (defined(__linux__) || defined(__ANDROID__))
@@ -29,11 +26,10 @@
 #endif

 #if defined(__FreeBSD__)
-#include <fcntl.h>
-#include <kvm.h>
-#include <sys/param.h>
-#include <sys/sysctl.h>
+#include <sys/types.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;
-    const char *nlistf, *memf;
-    nlistf = memf = "/dev/null";
-  
-    struct closer
-    {
-        void operator()(kvm_t * kd)
-        {
-            kvm_close(kd);
-        }
-    };
-
-    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
-    if (!kd) 
-    {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-        return vec;
-    }
-    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp))) 
+    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
+    if (proc_info) 
    {
        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 = nullptr;
-    const char *nlistf, *memf;
-    nlistf = memf = "/dev/null";
-  
-    struct closer
-    {
-        void operator()(kvm_t * kd)
-        {
-            kvm_close(kd);
-        }
-    };
-
-    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)}; 
-    if (!kd) 
-    {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-        return ppid;
-    }
-    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp)))
+    kinfo_proc *proc_info = kinfo_getproc(pid);
+    if (proc_info)
    {
        ppid = proc_info->ki_ppid;
+        free(proc_info);
    }
    else
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec)
    return ppid;
 }

 std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec) 
 {
    std::vector<pid_type> vec;
-    int cntp = 0;
-    kinfo_proc *proc_info = nullptr;
-    const char *nlistf, *memf;
-    nlistf = memf = "/dev/null";
-  
-    struct closer
-    {
-        void operator()(kvm_t * kd)
-        {
-            kvm_close(kd);
-        }
-    };
-
-    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
-    if (!kd) 
-    {
-        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-        return vec;
-    }
-    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp)))
+    int cntp = 0; 
+    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
+    if (proc_info)
    {
        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)
-{
-  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 {};
-}
+#error "Platform not supported"
 #endif

 std::vector<pid_type> all_pids()
--- a/src/posix/close_handles.cpp
+++ b/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,10 +45,9 @@ int fdwalk(int (*func)(void *, int), void *cd);

 #include <linux/version.h>

-// kernel has close_range
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,9,0) && !defined(BOOST_PROCESS_V2_POSIX_FORCE_DISABLE_CLOSE_RANGE)
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,11,0) // kernel has close_range

-// version is included by stdlib.h #include <gnu/libc-version.h>
+#include <gnu/libc-version.h>
 #if (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 34) // glibc is compiled with close_range support
 // https://man7.org/linux/man-pages/man2/close_range.2.html

@@ -60,10 +60,6 @@ int fdwalk(int (*func)(void *, int), void *cd);
 #if defined(SYS_close_range)

 #define BOOST_PROCESS_V2_HAS_CLOSE_RANGE 1
-#if !defined(CLOSE_RANGE_UNSHARE)
-#define CLOSE_RANGE_UNSHARE 2
-#endif
-
 int close_range(unsigned int first, unsigned int last, int flags)
 {
  return ::syscall(SYS_close_range, first, last, flags);
@@ -219,4 +215,4 @@ void close_all(const std::vector<int> & whitelist, error_code & ec)

 BOOST_PROCESS_V2_END_NAMESPACE

-#endif
+#endif
--- a/src/shell.cpp
+++ b/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
--- a/test/v1/Jamfile.jam
+++ b/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 ;
-lib shell32 ;
-lib Advapi32 ;
-lib Ntdll ;
+import os ;
+
+if [ os.name ] = NT
+{
+  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 filesystem       : usage-requirements <library>/boost/filesystem//boost_filesystem ;
-alias iostreams        : usage-requirements <library>/boost/iostreams//boost_iostreams ;
-alias system           : usage-requirements <library>/boost/system//boost_system ;
-alias thread           : usage-requirements <library>/boost/thread//boost_thread ;
-alias scope_exit       : usage-requirements <library>/boost/scope_exit//boost_scope_exit ;
-alias lambda           : usage-requirements <library>/boost/lambda//boost_lambda ;
-alias chrono           : usage-requirements <library>/boost/chrono//boost_chrono ;
+alias program_options  : /boost//program_options : <link>static ;
+alias filesystem       : /boost//filesystem      ;
+alias iostreams        : /boost//iostreams       ;
+alias system           : /boost//system          ;
+alias thread           : /boost//thread          ;
+alias coroutine        : /boost//coroutine       : <link>static ;

 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_test2.cpp filesystem system chrono           : [ test-options system_test2 ] : sparring_partner ]
+    [ run system_test1.cpp filesystem system                  : [ test-options system_test1 ] : sparring_partner ]
+    [ run system_test2.cpp filesystem system                  : [ test-options system_test2 ] : sparring_partner ]
    [ run 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_stackful.cpp filesystem system coroutine         : [ test-options async_system_stackful ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+    [ run async_system_future.cpp filesystem system 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_error.cpp filesystem system coroutine   : [ test-options async_system_stackful_error ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
-#    [ run async_system_stackful_except.cpp filesystem system coroutine  : [ test-options async_system_stackful_except ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
-    [ run async_system_stackless.cpp filesystem system                  : [ test-options async_system_stackless ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+    [ run async_system_stackful_except.cpp filesystem system coroutine  : [ test-options async_system_stackful_except ] : sparring_partner : <link>static <toolset>msvc:<cxxflags>/bigobj ]
+    [ run async_system_stackless.cpp filesystem system 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 ;
--- a/test/v1/async.cpp
+++ b/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;
--- a/test/v1/exit_code.cpp
+++ b/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();});


--- a/test/v1/system_test2.cpp
+++ b/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>
--- a/test/v1/wait.cpp
+++ b/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();});


--- a/test/v2/Jamfile.jam
+++ b/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 ;
-lib shell32 ;
-lib Advapi32 ;
-lib Ntdll ;
-lib user32 ;
-lib Bcrypt ;
+import os ;
+
+if [ os.name ] = NT
+{
+  lib ws2_32 ;
+  lib shell32 ;
+  lib Advapi32 ;
+  lib Ntdll ;
+  lib user32 ;
+  lib Bcrypt ;
+}

 project : requirements
-  <library>/boost/process//boost_process
  <define>BOOST_ASIO_NO_DEPRECATED
  <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
  <toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE
@@ -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 cstring_ref.cpp $(test_impl) ]
-    [ run environment.cpp $(test_impl) ]
-    [ run shell.cpp       $(test_impl) ]
+    [ run utf8.cpp test_impl ]
+    [ run cstring_ref.cpp test_impl ]
+    [ run environment.cpp test_impl ]
+    [ run shell.cpp test_impl ]
    ;

 test-suite with_target :
-    [ run pid.cpp     $(test_impl) : --log_level=all --catch_system_errors=no -- : target ]
-    [ run process.cpp $(test_impl) : --log_level=all --catch_system_errors=no -- : target ]
-    [ run windows.cpp $(test_impl) : --log_level=all --catch_system_errors=no -- : target : <build>no <target-os>windows:<build>yes <target-os>windows:<source>Advapi32 ]
-    [ run ext.cpp     $(test_impl) : --log_level=all --catch_system_errors=no -- : target : <target-os>darwin:<build>no ]
+    [ run pid.cpp     test_impl : --log_level=all --catch_system_errors=no -- : target ]
+    [ run process.cpp test_impl : --log_level=all --catch_system_errors=no -- : target ]
+    [ run windows.cpp test_impl : --log_level=all --catch_system_errors=no -- : target : <build>no <target-os>windows:<build>yes <target-os>windows:<source>Advapi32 ]
+    [ run ext.cpp     test_impl : --log_level=all --catch_system_errors=no -- : target : <target-os>darwin:<build>no ]
    ;

--- a/test/v2/process.cpp
+++ b/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();

--- a/test/v2/test_impl.cpp
+++ b/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>
--- a/test/v2/windows.cpp
+++ b/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>
Author	SHA1	Message	Date
Klemens Morgenstern	7919c9fd0b	b2 link fixes.	2024-07-12 07:52:51 +08:00
Klemens Morgenstern	2057b4e27f	c++14 constexpr fixes for environment_win.	2024-07-12 07:42:52 +08:00