Merge pull request #262 from boostorg/develop

Master update 1.80

.drone.star

@@ -0,0 +1,37 @@
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright Rene Rivera 2020.
+
+# For Drone CI we use the Starlark scripting language to reduce duplication.
+# As the yaml syntax for Drone CI is rather limited.
+#
+#
+globalenv={'B2_CI_VERSION': '1', 'B2_VARIANT': 'release'}
+linuxglobalimage="cppalliance/droneubuntu1804:1"
+windowsglobalimage="cppalliance/dronevs2019"
+
+def main(ctx):
+  return [
+    #freebsd_cxx("FreeBSD", "g++10",  packages="g++10",  buildtype="boost", buildscript="drone",                                                environment={ "VARIANT": "release", "TOOLSET": "gcc", "COMPILER": "g++", "CXXSTD": "11" }, globalenv=globalenv),
+  linux_cxx("docs", "", packages="docbook docbook-xml docbook-xsl xsltproc libsaxonhe-java default-jre-headless flex libfl-dev bison unzip rsync mlocate", 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),
+  linux_cxx("gcc 11 arm64", "g++-11", packages="g++-11", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu2004:multiarch", environment={                                           'B2_TOOLSET': 'gcc-11', 'B2_CXXSTD': '11',                                                                                            'DRONE_JOB_UUID': '17ba079169m'}, arch="arm64", globalenv=globalenv),
+  linux_cxx("GCC 10, Debug + Coverage", "g++-10", packages="g++-10 libssl-dev libffi-dev binutils-gold gdb mlocate", 
+                                                                                                 image="cppalliance/droneubuntu2004:1", buildtype="boost", buildscript="drone", environment={"GCOV": "gcov-10", "LCOV_VERSION": "1.15", "VARIANT": "process_coverage", "TOOLSET": "gcc", "COMPILER": "g++-10", "CXXSTD": "11", "DRONE_BEFORE_INSTALL" : "process_coverage", "CODECOV_TOKEN": {"from_secret": "codecov_token"}}, globalenv=globalenv, privileged=True),
+  # A set of jobs based on the earlier .travis.yml configuration:
+  linux_cxx("Default clang++ with libc++", "clang++-libc++", packages="libc++-dev mlocate", image="cppalliance/droneubuntu1604:1", buildtype="buildtype", buildscript="drone", environment={ "B2_TOOLSET": "clang-7", "B2_CXXSTD": "11", "VARIANT": "debug", "TOOLSET": "clang", "COMPILER": "clang++-libc++", "CXXSTD": "11", "CXX_FLAGS": "<cxxflags>-stdlib=libc++ <linkflags>-stdlib=libc++", "TRAVISCLANG" : "yes" }, globalenv=globalenv),
+  linux_cxx("Default g++", "g++", packages="mlocate", image="cppalliance/droneubuntu1604:1", buildtype="buildtype", buildscript="drone", environment={ "VARIANT": "release", "TOOLSET": "gcc", "COMPILER": "g++", "CXXSTD": "11" }, globalenv=globalenv),
+  linux_cxx("Clang 3.8, UBasan", "clang++-3.8", packages="clang-3.8 libssl-dev mlocate", llvm_os="precise", llvm_ver="3.8", image="cppalliance/droneubuntu1604:1", buildtype="boost", buildscript="drone", environment={"VARIANT": "process_ubasan", "TOOLSET": "clang", "COMPILER": "clang++-3.8", "CXXSTD": "11", "UBSAN_OPTIONS": 'print_stacktrace=1', "DRONE_BEFORE_INSTALL": "UBasan" }, globalenv=globalenv),
+  linux_cxx("gcc 6", "g++-6", packages="g++-6", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-6', 'B2_CXXSTD': '11', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
+  linux_cxx("clang 3.8", "clang++-3.8", packages="clang-3.8", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1604:1", environment={'B2_TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'B2_CXXSTD': '11', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv),
+  osx_cxx("clang", "g++", packages="", buildtype="boost",         buildscript="drone", environment={'B2_TOOLSET': 'clang', 'B2_CXXSTD': '11,17', 'DRONE_JOB_UUID': '91032ad7bb'}, globalenv=globalenv),
+  linux_cxx("coverity", "g++", packages="", buildtype="coverity", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'Coverity Scan', 'B2_TOOLSET': 'clang', 'DRONE_JOB_UUID': '472b07b9fc'}, globalenv=globalenv),
+  windows_cxx("msvc-14.1", "", image="cppalliance/dronevs2017",   buildtype="boost", buildscript="drone", environment={ "VARIANT": "release", "TOOLSET": "msvc-14.1", "CXXSTD": "11", "DEFINE" : "BOOST_BEAST_USE_STD_STRING_VIEW", "ADDRESS_MODEL": "64"}),
+  windows_cxx("msvc-14.3", "", image="cppalliance/dronevs2022:1", buildtype="boost", buildscript="drone", environment={ "VARIANT": "release", "TOOLSET": "msvc-14.3", "CXXSTD": "11", "DEFINE" : "BOOST_BEAST_USE_STD_STRING_VIEW", "ADDRESS_MODEL": "64"}),
+    ]
+
+# from https://github.com/boostorg/boost-ci
+load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")

.drone/drone.bat

@@ -0,0 +1,36 @@
+@ECHO ON
+setlocal enabledelayedexpansion
+
+if "%DRONE_JOB_BUILDTYPE%" == "boost" (
+
+echo '==================================> INSTALL'
+
+git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned --depth 1
+cp -prf boost-ci-cloned/ci .
+rm -rf boost-ci-cloned
+
+REM source ci/travis/install.sh
+REM The contents of install.sh below:
+
+for /F %%i in ("%DRONE_REPO%") do @set SELF=%%~nxi
+SET BOOST_CI_TARGET_BRANCH=%DRONE_COMMIT_BRANCH%
+SET BOOST_CI_SRC_FOLDER=%cd%
+
+call ci\common_install.bat
+
+echo '==================================> COMPILE'
+
+REM set B2_TARGETS=libs/!SELF!/test libs/!SELF!/example
+set B2_TARGETS=libs/!SELF!/test
+
+cd !BOOST_ROOT!
+call bootstrap.bat
+b2 headers
+b2 --debug-configuration variant=%VARIANT% cxxstd=%CXXSTD% define=%DEFINE% address-model=%ADDRESS_MODEL% toolset=%TOOLSET% --verbose-test libs/!SELF!/test -j3
+b2 --debug-configuration variant=%VARIANT% cxxstd=%CXXSTD% define=%DEFINE% address-model=%ADDRESS_MODEL% toolset=%TOOLSET% --verbose-test libs/!SELF!/example -j3
+
+) else if "%DRONE_JOB_BUILDTYPE%" == "standalone-windows" (
+
+REM not used
+
+)

.drone/drone.sh

@@ -0,0 +1,199 @@
+#!/bin/bash
+
+# Copyright 2020 Rene Rivera, Sam Darwin
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+set -xe
+
+export TRAVIS_BUILD_DIR=$(pwd)
+export DRONE_BUILD_DIR=$(pwd)
+export TRAVIS_BRANCH=$DRONE_BRANCH
+export TRAVIS_EVENT_TYPE=$DRONE_BUILD_EVENT
+export VCS_COMMIT_ID=$DRONE_COMMIT
+export GIT_COMMIT=$DRONE_COMMIT
+export REPO_NAME=$DRONE_REPO
+export USER=$(whoami)
+export CC=${CC:-gcc}
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+common_install () {
+  git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned --depth 1
+  cp -prf boost-ci-cloned/ci .
+  rm -rf boost-ci-cloned
+
+  if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+      unset -f cd
+  fi
+
+  export SELF=`basename $REPO_NAME`
+  export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH"
+  export BOOST_CI_SRC_FOLDER=$(pwd)
+
+  . ./ci/common_install.sh
+}
+
+if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then
+
+echo '==================================> INSTALL'
+
+common_install
+
+echo '==================================> SCRIPT'
+
+$BOOST_ROOT/libs/$SELF/ci/travis/build.sh
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "docs" ]; then
+
+echo '==================================> INSTALL'
+
+export SELF=`basename $REPO_NAME`
+
+pwd
+cd ..
+mkdir -p $HOME/cache && cd $HOME/cache
+if [ ! -d doxygen ]; then git clone -b 'Release_1_8_15' --depth 1 https://github.com/doxygen/doxygen.git && echo "not-cached" ; else echo "cached" ; fi
+cd doxygen
+cmake -H. -Bbuild -DCMAKE_BUILD_TYPE=Release
+cd build
+sudo make install
+cd ../..
+if [ ! -f saxonhe.zip ]; then wget -O saxonhe.zip https://sourceforge.net/projects/saxon/files/Saxon-HE/9.9/SaxonHE9-9-1-4J.zip/download && echo "not-cached" ; else echo "cached" ; fi
+unzip -o saxonhe.zip
+sudo rm /usr/share/java/Saxon-HE.jar
+sudo cp saxon9he.jar /usr/share/java/Saxon-HE.jar
+cd ..
+BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root --depth 1
+cd boost-root
+export BOOST_ROOT=$(pwd)
+git submodule update --init libs/context
+git submodule update --init tools/boostbook
+git submodule update --init tools/boostdep
+git submodule update --init tools/docca
+git submodule update --init tools/quickbook
+rsync -av $TRAVIS_BUILD_DIR/ libs/$SELF
+python tools/boostdep/depinst/depinst.py ../tools/quickbook
+./bootstrap.sh
+./b2 headers
+
+echo '==================================> SCRIPT'
+
+echo "using doxygen ; using boostbook ; using saxonhe ;" > tools/build/src/user-config.jam
+./b2 -j3 libs/$SELF/doc//boostrelease
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "codecov" ]; then
+
+echo '==================================> INSTALL'
+
+common_install
+
+echo '==================================> SCRIPT'
+
+cd $BOOST_ROOT/libs/$SELF
+ci/travis/codecov.sh
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "valgrind" ]; then
+
+echo '==================================> INSTALL'
+
+common_install
+
+echo '==================================> SCRIPT'
+
+cd $BOOST_ROOT/libs/$SELF
+ci/travis/valgrind.sh
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "standalone" ]; then
+
+echo '==================================> INSTALL'
+
+# Installing cmake with apt-get, so not required here:
+# pip install --user cmake
+
+echo '==================================> SCRIPT'
+
+export CXXFLAGS="-Wall -Wextra -Werror -std=c++17"
+mkdir __build_17
+cd __build_17
+cmake -DBOOST_JSON_STANDALONE=1 ..
+cmake --build .
+ctest -V .
+export CXXFLAGS="-Wall -Wextra -Werror -std=c++2a"
+mkdir ../__build_2a
+cd ../__build_2a
+cmake -DBOOST_JSON_STANDALONE=1 ..
+cmake --build .
+ctest -V .
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "coverity" ]; then
+
+echo '==================================> INSTALL'
+
+common_install
+
+echo '==================================> SCRIPT'
+
+if [ $VARIANT = "process_valgrind" ];
+then export USE_VALGRIND="testing.launcher=valgrind valgrind=on";
+fi ;
+
+if  [ -n "${COVERITY_SCAN_NOTIFICATION_EMAIL}" -a \( "$TRAVIS_BRANCH" = "develop" -o "$TRAVIS_BRANCH" = "master" \) -a \( "$DRONE_BUILD_EVENT" = "push" -o "$DRONE_BUILD_EVENT" = "cron" \) ] ; then
+cd $BOOST_ROOT/libs/$SELF
+ci/travis/coverity.sh
+fi
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "cmake-superproject" ]; then
+
+echo '==================================> INSTALL'
+
+common_install
+
+echo '==================================> COMPILE'
+
+export CXXFLAGS="-Wall -Wextra -Werror"
+
+mkdir __build_static
+cd __build_static
+cmake -DBOOST_ENABLE_CMAKE=1 -DBUILD_TESTING=ON -DBoost_VERBOSE=1 \
+    -DBOOST_INCLUDE_LIBRARIES=$SELF ..
+cmake --build .
+ctest --output-on-failure -R boost_$SELF
+
+cd ..
+
+mkdir __build_shared
+cd __build_shared
+cmake -DBOOST_ENABLE_CMAKE=1 -DBUILD_TESTING=ON -DBoost_VERBOSE=1 \
+    -DBOOST_INCLUDE_LIBRARIES=$SELF -DBUILD_SHARED_LIBS=ON ..
+cmake --build .
+ctest --output-on-failure -R boost_$SELF
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "cmake1" ]; then
+
+echo '==================================> INSTALL'
+
+pip install --user cmake
+
+echo '==================================> SCRIPT'
+
+export SELF=`basename $REPO_NAME`
+BOOST_BRANCH=develop && [ "$DRONE_BRANCH" == "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
+mkdir -p libs/$SELF
+cp -r $DRONE_BUILD_DIR/* libs/$SELF
+# git submodule update --init tools/boostdep
+git submodule update --init --recursive
+
+cd libs/$SELF
+
+../../../b2 -sBOOST_BUILD_PATH=.
+../../../b2 $MULTITHREAD with-valgrind address-model=64 architecture=x86 $USE_VALGRIND toolset=$TOOLSET cxxflags="--coverage -DBOOST_TRAVISCI_BUILD -std=$CXX_STANDARD" linkflags="--coverage" -sBOOST_BUILD_PATH=. $REPORT_CI
+../../../b2 $MULTITHREAD without-valgrind address-model=64 architecture=x86 toolset=$TOOLSET cxxflags="--coverage -DBOOST_TRAVISCI_BUILD -std=$CXX_STANDARD" linkflags="--coverage" -sBOOST_BUILD_PATH=. $REPORT_CI
+
+
+
+fi

.travis.yml

@@ -85,7 +85,7 @@ before_install:
   - git checkout $BOOST_BRANCH
   - git submodule update --init --merge
   - git remote set-branches --add origin $BOOST_BRANCH
-  - git pull --recurse-submodules
+  - git pull --recurse-submodules || true
   - git submodule update --init
   - git checkout $BOOST_BRANCH
   - git submodule foreach "git reset --quiet --hard; git clean -fxd"
@@ -131,6 +131,6 @@ after_success:
   - coveralls-lcov coverals/coverage.info
 
 after_script:
-  - curl -s https://report.ci/upload.py | python - --name="$BADGE test run"
   - bash <(curl -s https://codecov.io/bash)
-
+  - cd $BOOST/libs/$PROJECT_TO_TEST/test
+  - curl -s https://report.ci/report.py | python - --name="$BADGE test run"

CMakeLists.txt

@@ -0,0 +1,36 @@
+# Generated by `boostdep --cmake process`
+# Copyright 2020 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(boost_process VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_process INTERFACE)
+add_library(Boost::process ALIAS boost_process)
+
+target_include_directories(boost_process INTERFACE include)
+target_link_libraries(boost_process
+  INTERFACE
+    Boost::algorithm
+    Boost::asio
+    Boost::config
+    Boost::core
+    Boost::filesystem
+    Boost::fusion
+    Boost::iterator
+    Boost::move
+    Boost::optional
+    Boost::system
+    Boost::tokenizer
+    Boost::type_index
+    Boost::winapi
+)
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()
+

README.md

@@ -1,18 +1,21 @@
-# [Boost Process (Boost.Process)](https://github.com/klemens-morgenstern/boost-process)
+# [Boost Process (Boost.Process)](https://github.com/boostorg/process)
 
 Boost.process is a library for comfortable management of processes, released with boost 1.64.0.
 
 ### Test results
 
-Branches        | Linux | OSX | Windows | Code coverage | Matrix | 
-----------------|-------|-----|---------| ------------- |--------|
-Develop:        | [![Build Status](https://travis-ci.org/klemens-morgenstern/boost-process.svg?branch=develop&env=BADGE=linux)](https://travis-ci.org/klemens-morgenstern/boost-process) [![badge](https://api.report.ci/status/klemens-morgenstern/boost-process/badge.svg?branch=develop&build=linux)](https://api.report.ci/status/klemens-morgenstern/boost-process?branch=develop&build=linux) | [![Build Status](https://travis-ci.org/klemens-morgenstern/boost-process.svg?branch=develop&env=BADGE=osx)](https://travis-ci.org/klemens-morgenstern/boost-process)  [![badge](https://api.report.ci/status/klemens-morgenstern/boost-process/badge.svg?branch=develop&build=osx)](https://api.report.ci/status/klemens-morgenstern/boost-process?branch=develop&build=osx) | [![Build status](https://ci.appveyor.com/api/projects/status/peup7e6m0e1bb5ba/branch/develop?svg=true)](https://ci.appveyor.com/project/klemens-morgenstern/boost-process/branch/develop) [![badge](https://api.report.ci/status/klemens-morgenstern/boost-process/badge.svg?branch=develop&build=windows)](https://api.report.ci/status/klemens-morgenstern/boost-process?branch=develop&build=windows) | [![Coverage Status](https://coveralls.io/repos/github/klemens-morgenstern/boost-process/badge.svg?branch=develop)](https://coveralls.io/github/klemens-morgenstern/boost-process?branch=develop) | [![Matrix](https://img.shields.io/badge/matrix-develop-lightgray.svg)](http://www.boost.org/development/tests/develop/developer/process.html)
-Master:         | [![Build Status](https://travis-ci.org/klemens-morgenstern/boost-process.svg?branch=master&env=BADGE=linux)](https://travis-ci.org/klemens-morgenstern/boost-process)  [![badge](https://api.report.ci/status/klemens-morgenstern/boost-process/badge.svg?branch=master&build=linux)](https://api.report.ci/status/klemens-morgenstern/boost-process?branch=master&build=linux)   | [![Build Status](https://travis-ci.org/klemens-morgenstern/boost-process.svg?branch=master&env=BADGE=osx)](https://travis-ci.org/klemens-morgenstern/boost-process)   [![badge](https://api.report.ci/status/klemens-morgenstern/boost-process/badge.svg?branch=master&build=osx)](https://api.report.ci/status/klemens-morgenstern/boost-process?branch=master&build=osx)   | [![Build status](https://ci.appveyor.com/api/projects/status/peup7e6m0e1bb5ba/branch/master?svg=true)](https://ci.appveyor.com/project/klemens-morgenstern/boost-process/branch/master)   [![badge](https://api.report.ci/status/klemens-morgenstern/boost-process/badge.svg?branch=master&build=windows)](https://api.report.ci/status/klemens-morgenstern/boost-process?branch=master&build=windows) | [![Coverage Status](https://coveralls.io/repos/github/klemens-morgenstern/boost-process/badge.svg?branch=master)](https://coveralls.io/github/klemens-morgenstern/boost-process?branch=master)   | [![Matrix](https://img.shields.io/badge/matrix-master-lightgray.svg)](http://www.boost.org/development/tests/master/developer/process.html)
+| Branches | Linux / Windows                                                                                                                              | Code coverage                                                                                                                                | Matrix                                                                                                                                        | 
+|----------|----------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+| Develop: | [![Build Status](https://drone.cpp.al/api/badges/boostorg/process/status.svg)](https://drone.cpp.al/boostorg/process)                        | [![codecov](https://codecov.io/gh/boostorg/process/branch/develop/graph/badge.svg?token=AhunMqTSpA)](https://codecov.io/gh/boostorg/process) | [![Matrix](https://img.shields.io/badge/matrix-develop-lightgray.svg)](http://www.boost.org/development/tests/develop/developer/process.html) |
+| Master:  | [![Build Status](https://drone.cpp.al/api/badges/boostorg/process/status.svg?ref=refs/heads/develop)](https://drone.cpp.al/boostorg/process) | [![codecov](https://codecov.io/gh/boostorg/process/branch/master/graph/badge.svg?token=AhunMqTSpA)](https://codecov.io/gh/boostorg/process)  | [![Matrix](https://img.shields.io/badge/matrix-master-lightgray.svg)](http://www.boost.org/development/tests/master/developer/process.html)   |
 
 
-[Open Issues](https://github.com/klemens-morgenstern/boost-process/issues)
 
-[Latest developer documentation](http://klemens-morgenstern.github.io/process/)
+
+
+[Open Issues](https://github.com/boostorg/process/issues)
+
+[Latest developer documentation](https://www.boost.org/doc/libs/develop/doc/html/process.html)
 
 ### About
 This C++11 library is the current result of a long attempt to get a boost.process library, which is going on since 2006.

doc/Jamfile.jam

@@ -24,12 +24,13 @@ generators.register-standard common.copy : XML : XMLPROCESSWORKAROUND ;
 xmlprocessworkaround posix_pseudocode   : posix_pseudocode.xml   ; 
 xmlprocessworkaround windows_pseudocode : windows_pseudocode.xml ;
 
+path-constant INCLUDES : ../../.. ;
 
 doxygen autodoc
 :
-  ../../../boost/process.hpp
-  [ glob ../../../boost/process/*.hpp ]
-:
+  $(INCLUDES)/boost/process.hpp
+  [ glob $(INCLUDES)/boost/process/*.hpp ]
+  :
   <doxygen:param>EXCLUDE_SYMBOLS=BOOST_ASIO_INITFN_RESULT_TYPE
   <doxygen:param>PREDEFINED=BOOST_PROCESS_DOXYGEN
   <doxygen:param>HIDE_UNDOC_CLASSES=YES
@@ -42,11 +43,49 @@ doxygen autodoc
 
 
 
+doxygen reference_v2
+:
+  $(INCLUDES)/boost/process/v2.hpp
+  [ glob $(INCLUDES)/boost/process/v2/*.hpp ]
+  :
+  <doxygen:param>EXCLUDE_SYMBOLS=BOOST_ASIO_INITFN_RESULT_TYPE
+  <doxygen:param>PROJECT_NAME="Process V2"
+  <doxygen:param>PROJECT_BRIEF="The process library"
+  <doxygen:param>MACRO_EXPANSION=YES
+  <doxygen:param>EXPAND_ONLY_PREDEF=YES
+  <doxygen:param>"PREDEFINED=\\
+    GENERATING_DOCUMENTATION=1 \\
+    BOOST_PROCESS_V2_ASIO_NAMESPACE=boost::asio \\
+    \"BOOST_PROCESS_V2_BEGIN_NAMESPACE=namespace boost { namespace process { namespace 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_CONSTEXPR=constexpr \\
+    BOOST_CXX14_CONSTEXPR=constexpr \\
+    BOOST_ATTRIBUTE_NODISCARD=[[nodiscard]]
+    "
+  <doxygen.doxproc.id>reference_v2
+  <doxygen:param>SHOW_USED_FILES=NO
+  <doxygen:param>SHOW_FILES=NO
+  <doxygen:param>SHOW_NAMESPACES=YES
+  <doxygen:param>CLASS_DIAGRAMS=NO
+  <doxygen:param>SORT_MEMBERS_CTORS_1ST=YES
+  <doxygen:param>HIDE_UNDOC_CLASSES=NO
+  <xsl:path>.
+;
+
+
 boostbook standalone
 :
   process.qbk
 :
   <dependency>autodoc
+  <dependency>reference_v2
   <dependency>images
   <dependency>images_glob
   <xsl:param>boost.root=../../../..

doc/concepts.qbk

@@ -16,11 +16,11 @@ In that it is different than other facilities (like sockets) and provides anothe
 Pipes are typically used for interprocess communication. The main reason is, that pipes can be directly assigned to the process stdio, i.e. stderr, stdin and stdout.
 Additionally, half of the pipe can be inherited to the child process and closed in the father process. This will cause the pipe to be broken when the child process exits.
 
-Though please note, that if the the same thread reads and write to a pipe, it will only talk to itself.
+Though please note, that if the same thread reads and writes to a pipe, it will only talk to itself.
 
 [section:anonymous Anonymous Pipes]
 
-The usual type of pipes, are the anonymous ones. Since the have no name, 
+The most common pipes are anonymous. Since they have no name,
 a handle to them can only be obtained from duplicating either handle.
 
 In this library the following functions are used for the creation of unnamed pipes:
@@ -57,12 +57,12 @@ Every process is identified by a unique number[footnote it is unique as long as
 
 [section:exit_code Exit code]
 A process will return an integer value indicating whether it was successful. On posix
-there are more codes associated with that, but not so on windows. Therefore there is not such encoding currently in the library.
+there are more codes associated with that, but not so on windows. Therefore there is no such encoding currently in the library.
 However an exit code of zero means the process was successful, while one different than zero indicates an error. 
 [endsect]
 
 [section:termination Termination]
-Processes can also be forced to exit. There are two ways to do this, signal the process to so and wait, and just terminate the process without conditions.
+Processes can also be forced to exit. There are two ways to do this, signal the process to do so and wait, and just terminate the process without conditions.
 
 Usually the first approach is to signal an exit request, but windows - unlike posix - does not provide a consistent way to do this. Hence this is not part of the
 library and only the hard terminate is. 
@@ -79,4 +79,4 @@ The environment is a map of variables local to every process. The most significa
 
 [endsect]
 
-[endsect]
+[endsect]

doc/design.qbk

@@ -1,12 +1,12 @@
 [section:design Design Rationale]
 [section Scope]
-This library is meant to give an wrapper around the different OS-specific methods
+This library is meant to give a wrapper around the different OS-specific methods
 to launch processes. Its aim is to provide all functionality that is available on 
 those systems and allow the user to do all related things, which require using the OS APIs.
 
-[*This library does not try to provide a full library for everything process related] 
+[*This library does not try to provide a full library for everything process related.] 
 In many discussions the proposal was made to build boost.process into a DSEL [footnote Domain Specific Embedded Language] of some sort. 
-This is not the goal, it rather provides the facilities to build such a DSEL-Library on top of it. 
+This is not the goal, it rather provides the facilities to build such a DSEL-library on top of it. 
 Therefore the library also does [*not] force any particular use (such as only asynchronous communication) on its user. 
 It rather could be integrated with such a library.  
 
@@ -33,7 +33,7 @@ Both styles can also be mixed in some cases.
 system("gcc", "-c", args+={"main.cpp"});
 ```
 
-In the following section the avaible styles will be described. Note that the
+In the following section the available styles will be described. Note that the
 overload style is implemented via type traits, so the types will be listed. 
 
 [caution There is no guarantee in which order the arguments will be applied! 
@@ -54,7 +54,7 @@ interpret each string as an argument.
 ] 
 
 When using the overloading variant, a single string will result in a cmd interpretation, 
-several strings will yield a exe-args interpretation. Both version can be set explicitly:
+several strings will yield a exe-args interpretation. Both versions can be set explicitly:
 
 ```
 system("grep -c false /etc/passwd"); //cmd style
@@ -65,7 +65,7 @@ system(exe="grep", args={"-c", "false", "/etc/passwd"}); //exe-/args-
 ```
 
 [note If a '"' sign is used in the argument style, it will be passed as part of the argument.
-If the same effect it wanted with the cmd syntax, it ought to be escaped, i.e. '\\\"'. ]
+If the same effect is wanted with the cmd syntax, it ought to be escaped, i.e. '\\\"'. ]
 [note The `PATH` variable will automatically be searched in the command style, 
 but the one of the launching process, not the one passed to the child process.]
 [endsect]

doc/extend.qbk

@@ -15,14 +15,14 @@ To extend the library, the header [headerref boost/process/extend.hpp extend] is
 
 It only provides the explicit style for custom properties, but no implicit style.
 
-What this means is, that a custom initializer can be implemented, a reference to which can be passed to one of the launching functions.
-If a class inherits [classref boost::process::extend::handler] it will be regarded as a initializer and thus directly put into the sequence 
+What this means is, that a custom initializer can be implemented, a reference which can be passed to one of the launching functions.
+If a class inherits [classref boost::process::extend::handler] it will be regarded as an initializer and thus directly put into the sequence 
 the executor gets passed.
 
 [section:structure Structure]
 
 The executor calls different handlers of the initializers during the process launch. 
-The basic structure is consists of three functions, as given below:
+The basic structure consists of three functions, as given below:
 
 * [globalref boost::process::extend::on_setup on_setup]
 * [globalref boost::process::extend::on_error on_error]
@@ -53,7 +53,7 @@ namespace ex = bp::extend;
 __child__ c("foo", __on_success__=[](auto & exec) {std::cout << "hello world" << std::endl;});
 ```
 
-Considering that lambda can also capture values, data can easily be shared between handlers. 
+Considering that lambdas can also capture values, data can easily be shared between handlers. 
 
 To see which members the executor has, refer to [classref boost::process::extend::windows_executor windows_executor]
 and [classref boost::process::extend::posix_executor posix_executor].
@@ -86,7 +86,7 @@ __child__ c("foo", hello_world());
 
 [note The implementation is done via overloading, not overriding.]
 
-Every handler not implemented dafaults to [classref boost::process::extend::handler handler], where an empty handler is defined for each event.
+Every handler not implemented defaults to [classref boost::process::extend::handler handler], where an empty handler is defined for each event.
 
 [endsect]
 
@@ -100,7 +100,7 @@ this functionality is also available for extensions. If the class needs the __io
 ```
 struct async_foo : __handler__, __require_io_context__
 {
-    tempalte<typename Executor>
+    template<typename Executor>
     void on_setup(Executor & exec)
     {
         __io_context__ & ios = __get_io_context__(exec.seq); //gives us a reference and a compiler error if not present.
@@ -139,10 +139,10 @@ struct async_bar : __handler, __async_handler__
 
 [section:error Error handling]
 
-If an error occurs in the initializers it shall be told to the executor and not handles directly. This is because
-the behaviour can be changed through arguments passed to the launching function. Hence the the executor
+If an error occurs in the initializers it shall be told to the executor and not handled directly. This is because
+the behaviour can be changed through arguments passed to the launching function. Hence the executor
 has the function `set_error`, which takes an [@http://en.cppreference.com/w/cpp/error/error_code std::error_code] and a string.
-Depending on the cofiguration of the executor, this may either throw, set an internal `error_code`, or do nothing.
+Depending on the configuration of the executor, this may either throw, set an internal `error_code`, or do nothing.
 
 So let's take a simple example, where we set a randomly chosen `error_code`.
 
@@ -202,8 +202,8 @@ struct hello_exe : __handler__
 };
 ```
 
-So given our example, the definitions with the non-native exectur are still a template so that they will not be evaluated if not used. Hence this provides a
-way to implement systems-specific code without using the preprocessor.
+So given our example, the definitions with the non-native executor are still a template so that they will not be evaluated if not used. Hence this provides a
+way to implement system-specific code without using the preprocessor.
 
 [note If you only write a partial implementation, e.g. only for __posix_executor__, the other variants will default to __handler__].
 

doc/faq.qbk

@@ -47,7 +47,7 @@ while (is >> file)
 This will also deadlock, because the pipe does not close when the subprocess exits.
 So the `ipstream` will still look for data even though the process has ended.
 
-[note It is not possible to use automatically pipe-closing in this library, because 
+[note It is not possible to use automatic pipe-closing in this library, because 
 a pipe might be a file-handle (as for async pipes on windows).]
 
 But, since pipes are buffered, you might get incomplete data if you do this:
@@ -64,7 +64,7 @@ while (c.running())
 }
 ```
 
-It is therefore highly recommended that you use the asynchronous api if you are
+It is therefore highly recommended that you use the asynchronous API if you are
 not absolutely sure how the output will look.
 
 [endsect]

doc/process.qbk

@@ -11,6 +11,8 @@
     ]
 ]
 
+[note [link process.v2 Process V2] is available as  experimental]
+
 [include introduction.qbk]
 [include concepts.qbk]
 [include tutorial.qbk]
@@ -19,3 +21,4 @@
 [include faq.qbk]
 [xinclude autodoc.xml]
 [include acknowledgements.qbk]
+[include v2.qbk]

doc/tutorial.qbk

@@ -30,7 +30,7 @@
 [def asio_async_read [@http://www.boost.org/doc/libs/release/doc/html/boost_asio/reference/async_read.html boost::asio::async_read]]
 [def bp::environment  [classref boost::process::basic_environment bp::environment]]
 [def bp::native_environment  [classref boost::process::basic_native_environment bp::native_environment]]
-[def boost::this_process::environment [funcref boost::this_process::environment boost::this_process:deadlock :environment]]
+[def boost::this_process::environment [funcref boost::this_process::environment boost::this_process::environment]]
 [def std::chrono::seconds [@http://en.cppreference.com/w/cpp/chrono/duration std::chrono::seconds]]
 [def std::vector [@http://en.cppreference.com/w/cpp/container/vector std::vector]]
 
@@ -68,12 +68,12 @@ namespace bp = boost::process; //we will assume this for all further examples
 int result = bp::system("g++ main.cpp");
 ```
 
-If a single string (or the explicit form bp::cmd), it will be interpreted as a command line. 
+If a single string is given (or the explicit form bp::cmd), it will be interpreted as a command line. 
 That will cause the execution function to search the `PATH` variable to find the executable. 
 The alternative is the `exe-args` style, where the first string will be interpreted as a filename (including the path),
 and the rest as arguments passed to said function.   
 
-[note For more details on the `cmd`/`exe-args` style look [link boost_process.design.arg_cmd_style here]]
+[note For more details on the `cmd`/`exe-args` style look [link boost_process.design.arg_cmd_style here].]
 
 So as a first step, we'll use the `exe-args` style.
 
@@ -82,10 +82,10 @@ int result = bp::system("/usr/bin/g++", "main.cpp");
 ```
 
 With that syntax we still have "g++" hard-coded, so let's assume we get the string
-from an external source as `boost::filesystem::path`, we can do this too.
+from an external source as `boost::process::filesystem::path`, we can do this too.
 
 ```
-boost::filesystem::path p = "/usr/bin/g++"; //or get it from somewhere else.
+boost::process::filesystem::path p = "/usr/bin/g++"; //or get it from somewhere else.
 int result = bp::system(p, "main.cpp");
 ```
 
@@ -93,7 +93,7 @@ Now we might want to find the `g++` executable in the `PATH`-variable, as the `c
 `Boost.process` provides a function to this end: bp::search_path.
 
 ```
-boost::filesystem::path p = bp::search_path("g++"); //or get it from somewhere else.
+boost::process::filesystem::path p = bp::search_path("g++"); //or get it from somewhere else.
 int result = bp::system(p, "main.cpp");
 ```
 
@@ -141,7 +141,7 @@ things while the process is running and afterwards get the exit code. The call
 to child_wait is necessary, to obtain it and tell the operating system, that no
 one is waiting for the process anymore.
 
-[note You can also wait for a time span or a until a time point with __wait_for__ and __wait_until__]
+[note You can also wait for a time span or until a time point with __wait_for__ and __wait_until__.]
 
 [warning If you don't call wait on a child object, it will be terminated on destruction.
 This can be avoided by calling __detach__ beforehand]  
@@ -217,7 +217,7 @@ std::vector<std::string> read_outline(std::string & file)
 What this does is redirect the `stdout` of the process into a pipe and we read this
 synchronously.
 
-[note You can do the same thing with [globalref boost::process::std_err std_err]]
+[note You can do the same thing with [globalref boost::process::std_err std_err].]
 
 Now we get the name from `nm` and we might want to demangle it, so we use input and output.
 `nm` has a demangle option, but for the sake of the example, we'll use 
@@ -246,7 +246,7 @@ std::vector<std::string> read_demangled_outline(const std::string & file)
     
     std::vector<std::string> outline;
     
-    //we just use the same pipe, so the 
+    //we just use the same pipe, so the output of nm is directly passed as input to c++filt
     bp::child nm(bp::search_path("nm"), file,  bp::std_out > p); 
     bp::child filt(bp::search_path("c++filt"), bp::std_in < p, bp::std_out > is);
     
@@ -270,7 +270,7 @@ If you are familiar with [@http://www.boost.org/doc/libs/release/libs/asio/ boos
 you can use [classref boost::process::async_pipe async_pipe] which is implemented 
 as an I/O-Object and can be used like [classref boost::process::pipe pipe] as shown above.
 
-Now we get back to our compiling example. `nm` we might analyze it line by line,
+Now we get back to our compiling example. For `nm` we might analyze the output line by line,
 but the compiler output will just be put into one large buffer.
 
 With [@http://www.boost.org/doc/libs/release/libs/asio/ boost.asio] this is what it looks like.
@@ -290,7 +290,7 @@ ios.run();
 int result = c.exit_code();
 ```
 
-To make it easier, boost.process provides simpler interface for that, so that the buffer can be passed directly, 
+To make it easier, boost.process provides a simpler interface for that, so that the buffer can be passed directly, 
 provided we also pass a reference to an io_service. 
 
 ```
@@ -304,7 +304,7 @@ int result = c.exit_code();
 ```
 
 [note Passing an instance of io_service to the launching function automatically cause it to wait asynchronously for the exit, so no call of 
-[memberref boost::process::child::wait wait] is needed]
+[memberref boost::process::child::wait wait] is needed.]
  
 To make it even easier, you can use [@http://en.cppreference.com/w/cpp/thread/future std::future] for asynchronous operations
 (you will still need to pass a reference to a io_service) to the launching function, unless you use bp::system or bp::async_system.
@@ -331,7 +331,7 @@ auto err =  data.get();
 [endsect]
 [section:group Groups]
 
-When launching several processes, processes can be grouped together. 
+When launching several processes, they can be grouped together. 
 This will also apply for a child process, that launches other processes, 
 if they do not modify the group membership. E.g. if you call `make` which 
 launches other processes and call terminate on it, 
@@ -342,7 +342,7 @@ The two main reasons to use groups are:
 # Being able to terminate child processes of the child process
 # Grouping several processes into one, just so they can be terminated at once
 
-If we have program like `make`, which does launch its own child processes, 
+If we have a program like `make`, which does launch its own child processes, 
 a call of child_terminate might not suffice. I.e. if we have a makefile launching `gcc` 
 and use the following code, the `gcc` process will still run afterwards:
 
@@ -412,14 +412,14 @@ bp::system("stuff", env_);
 ```
 
 A more convenient way to modify the environment for the child is the 
-[globalref boost::process::env env] property, which the example as following:
+[globalref boost::process::env env] property, which can be used in the example as following:
 
 ```
 bp::system("stuff", bp::env["VALUE_1"]="foo", bp::env["VALUE_2"]+={"bar1", "bar2"});
 
 ```
 
-Please see to the [headerref boost/process/environment.hpp reference] for more information.
+Please see the [headerref boost/process/environment.hpp reference] for more information.
 
 [endsect]
 [endsect]

doc/v2.qbk

@@ -0,0 +1,11 @@
+[section:v2 Process V2]
+
+[include v2/introduction.qbk]
+[include v2/quickstart.qbk]
+[include v2/launcher.qbk]
+[include v2/start_dir.qbk]
+[include v2/stdio.qbk]
+[include v2/env.qbk]
+[xinclude reference_v2.xml]
+
+[endsect]

doc/v2/env.qbk

@@ -0,0 +1,48 @@
+[section:env Environment]
+
+The `environment` namespace provides all sorts of facilities to query and manipulate the environment of the current process.
+
+The api should be straight forward, but one oddity that needs to be pointed out is, that environment names
+are not case sensitive on windows. The key_traits class implements the proper traits depending on the current system.
+
+Additionally, environment can be lists separated by `:` or `;`; `environment::value` and
+`environment::value_view` can be used to iterate those.
+
+Beyond that, the requirements on an environment are a low as possible; 
+an environment is either a list of strings or a list of string-pairs. It is however recommented to use the environment types,
+as to have the right value comparisons.
+
+To note is the `find_executable` functions, which searches in an environment for an executable.
+
+```
+    // search in the current environment
+    auto exe = environment::find_executable("g++");
+
+    std::unordered_map<environment::key, environment::value> my_env =
+        {
+            {"SECRET", "THIS_IS_A_TEST"}
+            {"PATH", {"/bin", "/usr/bin"}
+        };
+
+    auto other_exe = environment::find_executable("g++", my_env);
+```
+
+[section:process_env Subprocess environment]
+
+The subprocess environment assignment follows the same constraints:
+
+```
+    asio::io_context ctx;
+    std::unordered_map<environment::key, environment::value> my_env =
+        {
+            {"SECRET", "THIS_IS_A_TEST"}
+            {"PATH", {"/bin", "/usr/bin"}
+        };
+    auto exe = find_executable("g++"), my_env);
+    process proc(ctx, exe, {"main.cpp"}, process_environment(my_env));
+    process pro2(ctx, exe, {"test.cpp"}, process_environment(my_env));
+```
+
+[endsect]
+
+[endsect]

doc/v2/introduction.qbk

@@ -0,0 +1,94 @@
+[section:introduction Introduction]
+
+Boost.process V2 is an redesign of boost.process, based on previous 
+design mistakes & improved system APIs.
+
+The major changes are
+
+* Simplified interface
+* Reliance on pidfd_open on linux
+* Full asio integration
+* Removed unreliable functionality
+* UTF8 Support
+* separate compilation
+* fd safe by default
+
+[section:simplified Simplified Interface]
+
+In process v1 one can define partial settings in the constructor of the process, 
+which has lead to a small DSL.
+
+ child c{exe="test", args+="--help", std_in < null(), env["FOO"] += "BAR"};
+
+While this looks fancy at first, it really does not scale well with more parameters.
+For process v2, the interfaces is simple: 
+
+ extern std::unordered_map<std::string, std::string> my_env;
+ extern asio::io_context ctx;
+ process proc(ctx, "./test", {"--help"}, process_io{nullptr, {}, {}}, process_environment(my_env));
+
+Every initializer adresses one logical compoent (e.g. stdio) instead of multiple ones accumulating.
+Furthermore, every process has a path and arguments, instead of a confusing mixture of cmd-style and 
+exe-args that can be randomly spread out.
+
+[endsect]
+
+[section:pidfd_open pidfd_open]
+
+Since process v1 came out, linux has moved along and added pidfd_open which allows users to get a 
+file descriptor for a process. This is much more reliable since it is not as easy to miss as a `SIGCHLD`.
+FreeBSD has a similar feature with `pdfork` which is also supported, while windows has provided `HANDLE`s 
+for processes all along.
+Unless the OS doesn't support it, process v2 will use file descriptors and handles to implement waiting 
+for processes.
+
+[endsect]
+
+[section:asio Full asio integration]
+
+Process v1 aimed to make asio optional, but synchronous IO with subprocesses usually means one is begging 
+for deadlocks.
+Since asio added pipes in boost 1.78, boost process V2 is fully asio based and uses it's pipes and 
+file-handles for the subprocess.
+
+[endsect]
+
+[section:unreliable Unreliable functionality]
+
+Certain parts of boost.process were not as reliable as they should've been. 
+
+This concerns especially the `wait_for`` and `wait_until` functions on the process.
+The latter are easy to do on windows, but posix does not provide an API for this. 
+Thus the wait_for used signals or fork, which was all but safe. 
+Since process v2 is based on asio and thus supports cancellation, 
+a wait_for can not safely be implemented with an async_wait + timeout.
+
+[endsect]
+
+[section:utf8 UTF-8]
+
+["UTF-8 or GTFO]--Vinnie Falco
+
+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),
+posix systems create a problem with inheriting file handles by default.
+
+Process V2 will automatically close all non-whitelisted descriptors, 
+without needing any option to enable it.
+
+[endsect]
+
+[endsect]

doc/v2/launcher.qbk

@@ -0,0 +1,128 @@
+[section:launchers Launcher]
+
+The process creation is done by a process_launcher. 
+The constructor of `process` will use the default_launcher, which varies by system.
+There are additional launcher available on most systems.
+
+[table:launchers Launcher overview
+    [[Name]                           [Summary] [Default on] [Available on]]
+    [[`windows::default_launcher`]    [Launcher using `CreateProcessW`]   [windows] [windows]]
+    [[`windows::as_user_launcher`]    [Launcher using `CreateProcessAsUserW`]    [] [windows]]
+    [[`windows::with_logon_launcher`] [Launcher using `CreateProcessWithLogonW`] [] [windows]]
+    [[`windows::with_token_launcher`] [Launcher using `CreateProcessWithTokenW`] [] [windows]]
+    [[`posix::default_launcher`]      [Launcher using fork & an error pipe] [most of posix]  [posix]]
+    [[`posix::fork_and_forget`]       [Launcher using fork without error pipe] []            [posix]]
+    [[`posix::pdfork_launcher`]       [Launcher using pdfork with an error pipe] [FreeBSD] [FreeBSD]]
+    [[`posix::vfork_launcher`]        [Launcher using vfork] [] [posix]]
+]
+
+A launcher is invoked through the call operator.
+
+```
+    auto l = windows::as_user_launcher((HANDLE)0xDEADBEEF);
+    asio::io_context ctx;
+    boost::system::eror_code ec;
+    auto proc = l(ctx, ec, "C:\\User\\boost\\Downloads\\totally_not_a_virus.exe", {});
+```
+
+The launcher will call certain functions on the initializer if they're present, as documented below.
+The initializer are used to modify the process behaviour.
+
+[section:linux Linux Launchers]
+
+The default and pdfork launchers on linux open an internal pipe to communicate errors that occur after forking back to the parent process.
+
+This can be prevented by using the `fork_and_forget_launcher`. 
+Alternatively, the `vfork_launcher` can report errors directly back to the parent process.
+
+Thus some calls to the initializers occur after forking from the child process.
+
+```
+    struct custom_initalizer
+    {
+        // functions called from the parent process:
+
+
+        // called before a call to fork. A returned error will cancel the launch.
+        template<typename Launcher>
+        error_code on_setup(Launcher & launcher, const filesystem::path &executable, const char * const * (&cmd_line));
+
+        // called for every initializer if an error occured during setup or process creation
+        template<typename Launcher>
+        void on_error(Launcher & launcher, const filesystem::path &executable, const char * const * (&cmd_line),
+                      const error_code & ec);
+
+        // called after successful process creation
+        template<typename Launcher>
+        void on_success(Launcher & launcher, const filesystem::path &executable, const char * const * (&cmd_line));
+
+        // called for every initializer if an error occured when forking, in addtion to on_error.
+        template<typename Launcher>
+        void on_fork_error(Launcher & launcher, const filesystem::path &executable, const char * const * (&cmd_line),
+                           const error_code & ec);
+
+
+        // called before a call to execve. A returned error will cancel the launch. Called from the child process.
+        template<typename Launcher>
+        error_code on_exec_setup(Launcher & launcher, const filesystem::path &executable, const char * const * (&cmd_line));
+
+
+        // called after a failed call to execve from the child process.
+        template<typename Launcher>
+        void on_exec_error(Launcher & launcher, const filesystem::path &executable, const char * const * (&cmd_line));
+    };
+```
+
+The call sequence on success:
+'''
+<imagedata fileref="boost_process/posix_success.svg"/>
+'''
+
+The call sequence when fork fails:
+'''
+<imagedata fileref="boost_process/posix_fork_err.svg"/>
+'''
+
+The call sequence when exec fails:
+'''
+<imagedata fileref="boost_process/posix_exec_err.svg"/>
+'''
+
+The launcher will close all non-whitelisted file descriptors after `on_exec_setup`.
+
+[endsect]
+
+[section:windows Windows Launchers]
+
+Windows launchers are pretty streight forward, they will call the following functions on the initializer if present.
+
+```
+    struct custom_initializer
+    {
+        // called before a call to CreateProcess. A returned error will cancel the launch.
+        template<typename Launcher>
+        error_code on_setup(Launcher & launcher, const filesystem::path &executable, std::wstring &cmd_line);
+
+        // called for every initializer if an error occured during setup or process creation
+        template<typename Launcher>
+        void on_error(Launcher & launcher, const filesystem::path &executable, std::wstring &cmd_line,
+                      const error_code & ec);
+
+        // called after successful process creation
+        template<typename Launcher>
+        void on_success(Launcher & launcher, const filesystem::path &executable, std::wstring &cmd_line);
+
+    };
+```
+
+[note All the additional launchers for windows inherit `default_launcher`]
+
+The call sequence is as follows:
+'''
+<imagedata fileref="boost_process/windows_exec.svg"/>
+'''
+
+[endsect]
+
+
+[endsect]

doc/v2/quickstart.qbk

@@ -0,0 +1,124 @@
+[section:quickstart Quickstrat]
+
+A process needs four things to be launched:
+
+* an asio execution_context / executor 
+* a path to an executable
+* a list of arguments
+* a variadic set of initializers
+
+```
+     // process(asio::any_io_executor, filesystem::path, range<string> args, AdditionalInitializers...)
+    asio::io_context ctx;
+    process proc(ctx, "/usr/bin/cp", {"source.txt", "target.txt"});
+```
+ 
+
+The started process can then be awaited or terminated.
+
+[section:lifetime Lifetime]
+
+If the process handle goes out of scope, it will terminate the subprocess.
+You can prevent this, by calling `proc.detach()`; do however note that this 
+can lead to zombie processes.
+
+A process that completed will deliver an exit-code, 
+which can be obtained by calling `.exit_code` on the exited process and which is
+also returned from `.wait()`.
+
+```
+ process proc("/bin/ls", {});
+ assert(proc.wait() == 0);
+```
+
+The normal exit-code is what the subprocess returned from `main`;
+posix will however add addtional information about the process. 
+This is called the `native_exit_code`.
+
+
+The `.running()` function can be used to detect if the process is still active.
+
+[endsect]
+
+[section:signal Signalling the subprocess]
+
+The parent process can signal the subprocess demaning certain actions.
+
+`.terminate` will cause the subprocess to exit immediately (`SIGKILL` on posix).
+This is the only reliable & portable way to end a subprocess.
+
+```
+    process proc("/bin/totally-not-a-virus", {});
+    proc.terminate();
+```
+
+`.request_exit` will ask the subprocess to shutdown (`SIGTERM` on posix),
+which the subprocess might ignore.
+
+```
+    process proc("/bin/bash", {});
+    proc.request_exit();
+    proc.wait();
+```
+
+`.interrupt` will send an SIGINT to the subprocess, which a subprocess might 
+interpret as a signal to shutdown.
+
+[warning interrupt requires the initializer `windows::create_new_process_group` to be set]
+
+```
+    process proc("/usr/bin/addr2line", {});
+    proc.request_exit();
+    proc.wait();
+```
+
+[endsect]
+
+[section:execute Execute functions]
+
+Process v2 provides  `execute` and `async_execute` functons that can be used for managed executions.
+
+```
+ assert(execute(process("/bin/ls", {}) == 0));
+```
+
+The async version supports cancellation and will forward cancellation types as follows:
+
+- asio::cancellation_type::total    -> interrupt
+- asio::cancellation_type::partial  -> request_exit
+- asio::cancellation_type::terminal -> terminate
+
+```
+    asio::io_context ctx;
+    asio::steady_timer timout{ctx, std::chrono::seconds(10)};
+
+    asio::cancellation_signal sig;
+    async_execute(process("/usr/bin/g++", {"hello_world.cpp"}), 
+                 asio::bind_cancellation_slot(sig.slot(), 
+                                              [&](error_code ec, int exit_code)
+                                              {
+                                                  timeout.cancel(); // we're done earlier
+                                              }));
+
+    timeout.async_wait(
+        [&](error_code ec) 
+        {
+            if (ec) // we were cancelled, do nothing
+                return ;
+            sig.emit(asio::cancellation_type::partial); 
+            // request exit first, but terminate after another 10 sec
+            timeout.expires_after(std::chrono::seconds(10));
+            timeout.async_wait(
+                [&](error_code ec)
+                {
+                    if (!ec)
+                        sig.emit(asio::cancellation_type::terminal); 
+                });
+            );
+        });
+
+```
+
+[endsect]
+
+[endsect]

doc/v2/start_dir.qbk

@@ -0,0 +1,16 @@
+[section:start_dir process_start_dir]
+
+The easier initializer to use is `process_start_dir`:
+
+```
+    asio::io_context ctx;
+    process ls(ctx, "/ls", {}, process_start_dir("/home"));
+    ls.wait();
+```
+
+This will run `ls` in the folder `/home` instead of the current folder.
+
+[warning If your path is relative, it may fail on posix, because the directory is changed before a call to execve.]
+
+
+[endsect]

doc/v2/stdio.qbk

@@ -0,0 +1,89 @@
+[section:stdio stdio]
+
+When using io with a subprocess, all three standard streams (stdin, stdout, stderr) get set for the child-process.
+The default setting is to inherit the parent process.
+
+This feature meant to be flexible, which is why there is little checking on the arguments assigned to one of those streams. 
+
+[section:pipe Pipe]
+
+asio pipes can be used for io. When using in process_stdio they will get 
+automatically connected and the other side will get assigned to the child process:
+
+```
+    asio::io_context ctx;
+    asio::readable_pipe rp;
+
+    process proc(ctx, "/usr/bin/g++", {"--version"}, process_stdio{{ /* in to default */}, rp, { /* err to default */ }});
+    std::string output;
+
+    system::error_code ec;
+    rp.read(asio::dynamic_buffer(output), ec);
+    assert(ec == asio::eof);
+    proc.wait();
+```
+
+readable pipes can be assigned to `out` an `err``, while writable_pipes can be assigned to `in`.
+
+[endsect]
+
+[section:file `FILE*`]
+
+`FILE*` can also be used for either side; this allows the `stdin`, `stderr`, `stdout` macros to be used:
+
+```
+    asio::io_context ctx;
+    // forward both stderr & stdout to stdout of the parent process
+    process proc(ctx, "/usr/bin/g++", {"--version"}, process_stdio{{ /* in to default */}, stdout, stdout});
+    proc.wait();
+```
+
+[endsect]
+
+[section:null `nullptr`]
+
+`nullptr` may be used to set a given stream to be opened on the null-device (`/dev/null` on posix, `NUL` on windows). 
+This is used to ignore output or give only EOF as input.
+
+```
+    asio::io_context ctx;
+    // ignore stderr
+    process proc(ctx, "/usr/bin/g++", {"--version"}, process_stdio{{ /* in to default */}, {}, nullptr});
+    proc.wait();
+```
+
+[endsect]
+
+
+[section:native_handle `native_handle`]
+
+A native handle can be used as well, which means an `int` on posix or a `HANDLE` on windows. 
+Furthermore, any object that has a `native_handle` returning that native handle type is valid, too.
+
+
+```
+    asio::io_context ctx;
+    // ignore stderr
+    asio::ip::tcp::socket sock{ctx};
+    connect_my_socket(sock);
+    process proc(ctx, "~/not-a-virus", {}, process_stdio{sock, sock, nullptr});
+    proc.wait();
+```
+
+[endsect]
+
+[section:popen popen]
+
+Additionally, process v2 provides a `popen` class. 
+It starts a process and connects pipes for stdin and stdout, so that the popen object can be used as a stream.
+
+```
+   popen proc(executor, "/usr/bin/addr2line, {argv[0]});
+   asio::write(proc, asio::buffer("main\n"));
+   std::string line;
+   asio::read_until(proc, asio::dynamic_buffer(line), '\n');
+```
+
+[endsect]
+
+[endsect]

example/intro.cpp

@@ -10,6 +10,9 @@
 //[intro
 #include <boost/process.hpp>
 
+#include <string>
+#include <iostream>
+
 using namespace boost::process;
 
 int main()

example/io.cpp

@@ -22,7 +22,7 @@ int main()
         bp::std_in < bp::null //null in
     );
 
-    boost::filesystem::path p = "input.txt";
+    boost::process::filesystem::path p = "input.txt";
 
     bp::system(
         "test.exe",

example/start_dir.cpp

@@ -8,7 +8,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/process.hpp>
-#include <boost/filesystem.hpp>
+#include <boost/process/filesystem.hpp>
 
 namespace bp = boost::process;
 
@@ -19,9 +19,9 @@ int main()
         bp::start_dir="../foo"
     );
 
-    boost::filesystem::path exe = "test.exe";
+    boost::process::filesystem::path exe = "test.exe";
     bp::system(
-        boost::filesystem::absolute(exe),
+        boost::process::filesystem::absolute(exe),
         bp::start_dir="../foo"
     );
 }

example/v2/Jamfile.jam

@@ -0,0 +1,17 @@
+# Copyright (c) 2022 Klemens Morgenstern
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+project : requirements
+  <include>../../..
+  <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+  <target-os>windows:<define>WIN32_LEAN_AND_MEAN
+;
+
+import testing ;
+
+alias filesystem   : /boost//filesystem : <link>static ;
+
+exe intro : intro.cpp filesystem ;
+exe intro_popen : intro_popen.cpp filesystem ;

example/v2/intro.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2022Klemens Morgernstern
+//
+// 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)
+
+//[intro
+#include <boost/process/v2.hpp>
+
+#include <boost/asio/read.hpp>
+#include <boost/asio/readable_pipe.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <string>
+#include <iostream>
+
+namespace proc   = boost::process::v2;
+namespace asio   = boost::asio;
+
+
+int main()
+{
+    asio::io_context ctx;
+    asio::readable_pipe p{ctx};
+
+    const auto exe = proc::environment::find_executable("gcc");
+
+    proc::process c{ctx, exe, {"--version"}, proc::process_stdio{nullptr, p}};
+
+    std::string line;
+    boost::system::error_code ec;
+
+    auto sz = asio::read(p, asio::dynamic_buffer(line), ec);
+    assert(ec == asio::error::eof);
+
+    std::cout << "Gcc version: '"  << line << "'" << std::endl;
+
+    c.wait();
+}
+//]

example/v2/intro_popen.cpp

@@ -0,0 +1,36 @@
+// Copyright (c) 2022Klemens Morgernstern
+//
+// 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)
+
+//[intro
+#include <boost/process/v2.hpp>
+
+#include <boost/asio/read.hpp>
+#include <boost/asio/readable_pipe.hpp>
+#include <boost/system/error_code.hpp>
+
+#include <string>
+#include <iostream>
+
+namespace proc   = boost::process::v2;
+namespace asio   = boost::asio;
+
+
+int main()
+{
+    asio::io_context ctx;
+    const auto exe = proc::environment::find_executable("gcc");
+    proc::popen c{ctx, exe, {"--version"}};
+
+    std::string line;
+    boost::system::error_code ec;
+
+    auto sz = asio::read(c, asio::dynamic_buffer(line), ec);
+    assert(ec == asio::error::eof);
+
+    std::cout << "Gcc version: '"  << line << "'" << std::endl;
+
+    c.wait();
+}
+//]

example/windows.cpp

@@ -8,6 +8,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/process.hpp>
+#include <boost/process/extend.hpp>
 #include <boost/process/windows.hpp>
 #include <iostream>
 
@@ -22,9 +23,9 @@ int main()
 
 
     bp::system("test.exe",
-        bp::on_setup([](auto &e)
+        bp::extend::on_setup([](auto &e)
             { e.startup_info.dwFlags = STARTF_RUNFULLSCREEN; }),
-        bp::on_error([](auto&, const std::error_code & ec)
+        bp::extend::on_error([](auto&, const std::error_code & ec)
             { std::cerr << ec.message() << std::endl; })
         );
 }

include/boost/process/args.hpp

@@ -138,7 +138,7 @@ struct args_
 
     arg_setter_<char, true> operator()(std::initializer_list<const char*> &&range) const
     {
-        return arg_setter_<char>(range.begin(), range.end());
+        return arg_setter_<char, true>(range.begin(), range.end());
     }
     arg_setter_<char, true> operator+=(std::initializer_list<const char*> &&range) const
     {
@@ -146,11 +146,11 @@ struct args_
     }
     arg_setter_<char, false> operator= (std::initializer_list<const char*> &&range) const
     {
-        return arg_setter_<char, true>(range.begin(), range.end());
+        return arg_setter_<char, false>(range.begin(), range.end());
     }
     arg_setter_<char, true> operator()(std::initializer_list<std::string> &&range) const
     {
-        return arg_setter_<char>(range.begin(), range.end());
+        return arg_setter_<char, true>(range.begin(), range.end());
     }
     arg_setter_<char, true> operator+=(std::initializer_list<std::string> &&range) const
     {
@@ -158,12 +158,12 @@ struct args_
     }
     arg_setter_<char, false> operator= (std::initializer_list<std::string> &&range) const
     {
-        return arg_setter_<char, true>(range.begin(), range.end());
+        return arg_setter_<char, false>(range.begin(), range.end());
     }
 
     arg_setter_<wchar_t, true> operator()(std::initializer_list<const wchar_t*> &&range) const
     {
-        return arg_setter_<wchar_t>(range.begin(), range.end());
+        return arg_setter_<wchar_t, true>(range.begin(), range.end());
     }
     arg_setter_<wchar_t, true> operator+=(std::initializer_list<const wchar_t*> &&range) const
     {
@@ -171,11 +171,11 @@ struct args_
     }
     arg_setter_<wchar_t, false> operator= (std::initializer_list<const wchar_t*> &&range) const
     {
-        return arg_setter_<wchar_t, true>(range.begin(), range.end());
+        return arg_setter_<wchar_t, false>(range.begin(), range.end());
     }
     arg_setter_<wchar_t, true> operator()(std::initializer_list<std::wstring> &&range) const
     {
-        return arg_setter_<wchar_t>(range.begin(), range.end());
+        return arg_setter_<wchar_t, true>(range.begin(), range.end());
     }
     arg_setter_<wchar_t, true> operator+=(std::initializer_list<std::wstring> &&range) const
     {
@@ -183,7 +183,7 @@ struct args_
     }
     arg_setter_<wchar_t, false> operator= (std::initializer_list<std::wstring> &&range) const
     {
-        return arg_setter_<wchar_t, true>(range.begin(), range.end());
+        return arg_setter_<wchar_t, false>(range.begin(), range.end());
     }
 };
 

include/boost/process/async.hpp

@@ -109,10 +109,10 @@ with `function` being a callable object with the signature `(int, const std::err
 \code{.cpp}
 io_context ios;
 
-child c("ls", on_exit=[](int exit, const std::error_code& ec_in){});
+child c("ls", ios, on_exit=[](int exit, const std::error_code& ec_in){});
 
 std::future<int> exit_code;
-chlid c2("ls", on_exit=exit_code);
+chlid c2("ls", ios, on_exit=exit_code);
 
 \endcode
 

include/boost/process/async_pipe.hpp

@@ -47,6 +47,8 @@ public:
      */
     typedef platform_specific handle_type;
 
+    typedef typename handle_type::executor_type executor_type;
+
     /** Construct a new async_pipe, does automatically open the pipe.
      * Initializes source and sink with the same io_context.
      * @note Windows creates a named pipe here, where the name is automatically generated.

include/boost/process/cmd.hpp

@@ -43,7 +43,7 @@ namespace boost { namespace process { namespace detail {
 
 struct cmd_
 {
-    constexpr cmd_() {}
+    constexpr cmd_() = default;
 
     template<typename Char>
     inline api::cmd_setter_<Char> operator()(const Char *s) const

include/boost/process/detail/basic_cmd.hpp

@@ -168,7 +168,7 @@ struct exe_builder
     string_type exe;
     std::vector<string_type> args;
 
-    void operator()(const boost::filesystem::path & data)
+    void operator()(const boost::process::filesystem::path & data)
     {
         not_cmd = true;
         if (exe.empty())

include/boost/process/detail/child_decl.hpp

@@ -60,7 +60,7 @@ public:
     explicit child(child_handle &&ch, const std::shared_ptr<std::atomic<int>> &ptr) : _child_handle(std::move(ch)), _exit_status(ptr) {}
     explicit child(child_handle &&ch) : _child_handle(std::move(ch)) {}
 
-    explicit child(pid_t & pid) : _child_handle(pid), _attached(false) {};
+    explicit child(pid_t pid) : _child_handle(pid), _attached(false) {};
     child(const child&) = delete;
     child(child && lhs) noexcept
         : _child_handle(std::move(lhs._child_handle)),
@@ -73,7 +73,7 @@ public:
 
     template<typename ...Args>
     explicit child(Args&&...args);
-    child() {}
+    child() { } // Must be kept non defaulted for MSVC 14.1 & 14.2 #113
     child& operator=(const child&) = delete;
     child& operator=(child && lhs)
     {

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

@@ -7,6 +7,7 @@
 #define BOOST_PROCESS_DETAIL_POSIX_ASIO_FWD_HPP_
 
 #include <memory>
+#include <boost/asio/ts/netfwd.hpp>
 
 namespace boost { namespace asio {
 
@@ -20,39 +21,19 @@ template<typename Allocator>
 class basic_streambuf;
 
 typedef basic_streambuf<std::allocator<char>> streambuf;
-class io_context;
 
-class executor;
-
-
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class signal_set_service;
-template <typename SignalSetService>
-
-class basic_signal_set;
-typedef basic_signal_set<signal_set_service> signal_set;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_signal_set;
-typedef basic_signal_set<executor> signal_set;
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
+typedef basic_signal_set<any_io_executor> signal_set;
 
 template <typename Handler>
 class basic_yield_context;
 
 namespace posix {
 
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class stream_descriptor_service;
-
-template <typename StreamDesscriptorService>
-class basic_stream_descriptor;
-typedef basic_stream_descriptor<stream_descriptor_service> stream_descriptor;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_stream_descriptor;
-typedef basic_stream_descriptor<executor> stream_descriptor;
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
+typedef basic_stream_descriptor<any_io_executor> stream_descriptor;
 
 } //posix
 } //asio

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

@@ -145,8 +145,11 @@ struct async_out_future : ::boost::process::detail::posix::handler_base_ext,
                     {
                         std::istream is (buffer_.get());
                         Type arg;
-                        arg.resize(buffer_->size());
-                        is.read(&*arg.begin(), buffer_->size());
+                        if (buffer_->size() > 0)
+                        {
+                            arg.resize(buffer_->size());
+                            is.read(&*arg.begin(), buffer_->size());
+                        }
                         promise_->set_value(std::move(arg));
                     }
                 });

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

@@ -23,6 +23,12 @@ class async_pipe
 public:
     typedef int native_handle_type;
     typedef ::boost::asio::posix::stream_descriptor handle_type;
+    typedef typename handle_type::executor_type executor_type;
+
+    executor_type get_executor()
+    {
+        return _source.get_executor();
+    }
 
     inline async_pipe(boost::asio::io_context & ios) : async_pipe(ios, ios) {}
 
@@ -44,8 +50,8 @@ public:
     inline async_pipe(const async_pipe& lhs);
     async_pipe(async_pipe&& lhs)  : _source(std::move(lhs._source)), _sink(std::move(lhs._sink))
     {
-        lhs._source.assign (-1);
-        lhs._sink  .assign (-1);
+        lhs._source = ::boost::asio::posix::stream_descriptor{lhs._source.get_executor()};
+        lhs._sink   = ::boost::asio::posix::stream_descriptor{lhs._sink.  get_executor()};
     }
 
     template<class CharT, class Traits = std::char_traits<CharT>>
@@ -70,10 +76,8 @@ public:
 
     ~async_pipe()
     {
-        if (_sink .native_handle()  != -1)
-            ::close(_sink.native_handle());
-        if (_source.native_handle() != -1)
-            ::close(_source.native_handle());
+        boost::system::error_code ec;
+        close(ec);
     }
 
     template<class CharT, class Traits = std::char_traits<CharT>>

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

@@ -11,7 +11,7 @@
 #define BOOST_PROCESS_POSIX_PIPE_HPP
 
 
-#include <boost/filesystem.hpp>
+#include <boost/process/filesystem.hpp>
 #include <boost/process/detail/posix/compare_handles.hpp>
 #include <system_error>
 #include <array>
@@ -82,18 +82,26 @@ public:
 
     int_type write(const char_type * data, int_type count)
     {
-        auto write_len = ::write(_sink, data, count * sizeof(char_type));
-        if (write_len == -1)
-            ::boost::process::detail::throw_last_error();
-
+        int_type write_len;
+        while ((write_len = ::write(_sink, data, count * sizeof(char_type))) == -1)
+        {
+            //Try again if interrupted
+            auto err = errno;
+            if (err != EINTR)
+                ::boost::process::detail::throw_last_error();
+        }
         return write_len;
     }
     int_type read(char_type * data, int_type count)
     {
-        auto read_len = ::read(_source, data, count * sizeof(char_type));
-        if (read_len == -1)
-            ::boost::process::detail::throw_last_error();
-
+        int_type read_len;
+        while ((read_len = static_cast<int_type>(::read(_source, data, count * sizeof(char_type)))) == -1)
+        {
+            //Try again if interrupted
+            auto err = errno;
+            if (err != EINTR)
+                ::boost::process::detail::throw_last_error();
+        }
         return read_len;
     }
 

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

@@ -22,7 +22,7 @@ struct close_out : handler_base_ext
     template <class Executor>
     inline void on_exec_setup(Executor &e) const;
 
-    std::array<int, 2> get_used_handles() {return {p1 != -1 ? p1 : p2, p2 != -1 ? p2 : p1};}
+    std::array<int, 2> get_used_handles() {return {{p1 != -1 ? p1 : p2, p2 != -1 ? p2 : p1}};}
 };
 
 template<>

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

@@ -56,6 +56,7 @@ public:
     {
         _buffer = _load();
         _impl = _load_var(_buffer);
+        _env_impl = _impl.data();
     }
 
     string_type get(const pointer_type id) { return get(string_type(id)); }
@@ -94,7 +95,7 @@ public:
     native_environment_impl & operator=(native_environment_impl && ) = default;
     native_handle_type _env_impl = _impl.data();
 
-    native_handle_type native_handle() const {return environ;}
+    native_handle_type native_handle() const {return _env_impl;}
 };
 
 template<>
@@ -230,7 +231,7 @@ template<typename Char>
 inline auto basic_environment_impl<Char>::get(const string_type &id) -> string_type
 {
     auto itr = std::find_if(_data.begin(), _data.end(), 
-            [&](const string_type & st)
+            [&](const string_type & st) -> bool
             {
                 if (st.size() <= id.size())
                     return false;
@@ -250,7 +251,7 @@ template<typename Char>
 inline void basic_environment_impl<Char>::set(const string_type &id, const string_type &value)
 {
     auto itr = std::find_if(_data.begin(), _data.end(), 
-        [&](const string_type & st)
+        [&](const string_type & st) -> bool
         {
             if (st.size() <= id.size())
                 return false;
@@ -270,7 +271,7 @@ template<typename Char>
 inline void  basic_environment_impl<Char>::reset(const string_type &id)
 {
     auto itr = std::find_if(_data.begin(), _data.end(), 
-        [&](const string_type & st)
+        [&](const string_type & st) -> bool
         {
             if (st.size() <= id.size())
                 return false;
@@ -294,7 +295,11 @@ std::vector<Char*> basic_environment_impl<Char>::_load_var(std::vector<std::basi
     ret.reserve(data.size() +1);
 
     for (auto & val : data)
+    {
+        if (val.empty())
+            val.push_back(0);
         ret.push_back(&val.front());
+    }
 
     ret.push_back(nullptr);
     return ret;

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

@@ -26,6 +26,8 @@
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
 
+#include <boost/core/ignore_unused.hpp>
+
 namespace boost { namespace process { namespace detail { namespace posix {
 
 template<typename Executor>
@@ -149,15 +151,15 @@ class executor
 
     int _pipe_sink = -1;
 
+
     void write_error(const std::error_code & ec, const char * msg)
     {
         //I am the child
-        int len = ec.value();
-        ::write(_pipe_sink, &len, sizeof(int));
+        const auto len = std::strlen(msg);
+        int data[2] = {ec.value(), static_cast<int>(len + 1)};
 
-        len = std::strlen(msg) + 1;
-        ::write(_pipe_sink, &len, sizeof(int));
-        ::write(_pipe_sink, msg, len);
+        boost::ignore_unused(::write(_pipe_sink, &data[0], sizeof(int) * 2));
+        boost::ignore_unused(::write(_pipe_sink, msg, len));
     }
 
     void internal_error_handle(const std::error_code &ec, const char* msg, boost::mpl::true_ , boost::mpl::false_, boost::mpl::false_)
@@ -273,14 +275,15 @@ class executor
         prepare_cmd_style_fn = exe;
         if ((prepare_cmd_style_fn.find('/') == std::string::npos) && ::access(prepare_cmd_style_fn.c_str(), X_OK))
         {
-            auto e = ::environ;
-            while ((*e != nullptr) && !boost::starts_with(*e, "PATH="))
+            const auto * e = ::environ;
+            while ((e != nullptr) && (*e != nullptr) && !boost::starts_with(*e, "PATH="))
                 e++;
 
-            if (e != nullptr)
+            if ((e != nullptr) && (*e != nullptr))
             {
                 std::vector<std::string> path;
-                boost::split(path, *e, boost::is_any_of(":"));
+                //the beginning of the string contains "PATH="
+                boost::split(path, (*e) + 5, boost::is_any_of(":"));
 
                 for (const std::string & pp : path)
                 {
@@ -325,6 +328,13 @@ public:
     }
     void set_error(const std::error_code &ec, const std::string &msg) {set_error(ec, msg.c_str());};
 
+    std::vector<int> get_used_handles() const 
+    {
+        if (_pipe_sink == -1)
+            return {};
+        else
+            return {_pipe_sink};
+    };
 };
 
 template<typename Sequence>

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

@@ -8,7 +8,8 @@
 
 #include <fcntl.h>
 #include <string>
-#include <boost/filesystem/path.hpp>
+#include <boost/process/filesystem.hpp>
+#include <boost/core/exchange.hpp>
 
 namespace boost { namespace process { namespace detail { namespace posix {
 
@@ -23,7 +24,7 @@ struct file_descriptor
 
 
     file_descriptor() = default;
-    explicit file_descriptor(const boost::filesystem::path& p, mode_t mode = read_write)
+    explicit file_descriptor(const boost::process::filesystem::path& p, mode_t mode = read_write)
         : file_descriptor(p.native(), mode)
     {
     }
@@ -39,10 +40,22 @@ struct file_descriptor
     }
 
     file_descriptor(const file_descriptor & ) = delete;
-    file_descriptor(file_descriptor && ) = default;
+    file_descriptor(file_descriptor &&other)
+        : _handle(boost::exchange(other._handle, -1))
+    {
+    }
 
     file_descriptor& operator=(const file_descriptor & ) = delete;
-    file_descriptor& operator=(file_descriptor && ) = default;
+    file_descriptor& operator=(file_descriptor &&other)
+    {
+        if (this != &other)
+        {
+            if (_handle != -1)
+                ::close(_handle);
+            _handle = boost::exchange(other._handle, -1);
+        }
+        return *this;
+    }
 
     ~file_descriptor()
     {

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

@@ -26,7 +26,7 @@ struct file_in : handler_base_ext, ::boost::process::detail::uses_handles
 
     std::array<int, 2> get_used_handles()
     {
-        return {STDIN_FILENO, handle};
+        return {{STDIN_FILENO, handle}};
     }
 
     template<typename T>

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

@@ -42,7 +42,7 @@ struct group_handle
     }
 
     void add(handle_t proc)
-    {   
+    {
         if (::setpgid(proc, grp))
             throw_last_error();
     }

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

@@ -11,6 +11,8 @@
 #include <dirent.h>
 #include <sys/stat.h>
 #include <algorithm>
+#include <memory>
+#include <cstdlib>
 #include <boost/process/detail/posix/handler.hpp>
 
 namespace boost { namespace process { namespace detail { namespace posix {

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2106 Klemens D. Morgenstern
+// Copyright (c) 2016 Klemens D. Morgenstern
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

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

@@ -25,7 +25,7 @@ struct null_in : handler_base_ext, ::boost::process::detail::uses_handles
 
     std::array<int, 2> get_used_handles()
     {
-        return {STDIN_FILENO, source.handle()};
+        return {{STDIN_FILENO, source.handle()}};
     }
 
 

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

@@ -6,26 +6,39 @@
 #ifndef BOOST_PROCESS_POSIX_ON_EXIT_HPP_
 #define BOOST_PROCESS_POSIX_ON_EXIT_HPP_
 
+#include <boost/asio/execution.hpp>
+#include <boost/process/async.hpp>
 #include <boost/process/detail/config.hpp>
 #include <boost/process/detail/handler_base.hpp>
 #include <boost/process/detail/posix/async_handler.hpp>
 #include <system_error>
 #include <functional>
 
-namespace boost { namespace process { namespace detail { namespace posix {
+namespace boost { namespace process { namespace detail {
+
+template<typename Tuple>
+inline asio::io_context& get_io_context(const Tuple & tup);
+
+namespace posix {
 
 struct on_exit_ : boost::process::detail::posix::async_handler
 {
     std::function<void(int, const std::error_code&)> handler;
     on_exit_(const std::function<void(int, const std::error_code&)> & handler) : handler(handler)
     {
-
     }
 
     template<typename Executor>
-    std::function<void(int, const std::error_code&)> on_exit_handler(Executor&) 
+    std::function<void(int, const std::error_code&)> on_exit_handler(Executor& exec)
     {
-        return handler;
+        auto v = boost::asio::prefer(boost::process::detail::get_io_context(exec.seq).get_executor(),
+                                     boost::asio::execution::outstanding_work.tracked);
+        auto handler_ = this->handler;
+        return
+            [handler_, v](int exit_code, const std::error_code & ec)
+            {
+                handler_(exit_code, ec);
+            };
 
     }
 };

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

@@ -27,7 +27,7 @@ struct pipe_in : handler_base_ext, ::boost::process::detail::uses_handles
 
     std::array<int, 3> get_used_handles()
     {
-        return {STDIN_FILENO, source, sink};
+        return {{STDIN_FILENO, source, sink}};
     }
 
 

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

@@ -11,7 +11,7 @@
 #define BOOST_PROCESS_POSIX_SEARCH_PATH_HPP
 
 #include <boost/process/detail/config.hpp>
-#include <boost/filesystem.hpp>
+#include <boost/process/filesystem.hpp>
 #include <boost/tokenizer.hpp>
 #include <string>
 #include <stdexcept>
@@ -20,15 +20,15 @@
 
 namespace boost { namespace process { namespace detail { namespace posix {
 
-inline boost::filesystem::path search_path(
-        const boost::filesystem::path &filename,
-        const std::vector<boost::filesystem::path> &path)
+inline boost::process::filesystem::path search_path(
+        const boost::process::filesystem::path &filename,
+        const std::vector<boost::process::filesystem::path> &path)
 {
-    for (const boost::filesystem::path & pp : path)
+    for (const boost::process::filesystem::path & pp : path)
     {
         auto p = pp / filename;
         boost::system::error_code ec;
-        bool file = boost::filesystem::is_regular_file(p, ec);
+        bool file = boost::process::filesystem::is_regular_file(p, ec);
         if (!ec && file && ::access(p.c_str(), X_OK) == 0)
             return p;
     }

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

@@ -12,16 +12,16 @@
 
 #include <boost/process/detail/config.hpp>
 #include <boost/system/error_code.hpp>
-#include <boost/filesystem/path.hpp>
+#include <boost/process/filesystem.hpp>
 
 namespace boost { namespace process { namespace detail { namespace posix {
 
-inline boost::filesystem::path shell_path()
+inline boost::process::filesystem::path shell_path()
 {
     return "/bin/sh";
 }
 
-inline boost::filesystem::path shell_path(std::error_code &ec)
+inline boost::process::filesystem::path shell_path(std::error_code &ec)
 {
     ec.clear();
     return "/bin/sh";

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

@@ -20,7 +20,7 @@ namespace boost { namespace process { namespace detail { namespace posix {
 
 class sigchld_service : public boost::asio::detail::service_base<sigchld_service>
 {
-    boost::asio::io_context::strand _strand{get_io_context()};
+    boost::asio::strand<boost::asio::io_context::executor_type> _strand{get_io_context().get_executor()};
     boost::asio::signal_set _signal_set{get_io_context(), SIGCHLD};
 
     std::vector<std::pair<::pid_t, std::function<void(int, std::error_code)>>> _receivers;
@@ -48,9 +48,22 @@ public:
                     int status;
                     auto pid_res = ::waitpid(pid, &status, WNOHANG);
                     if (pid_res < 0)
-                        h(-1, get_last_error());
+                    {
+                        auto ec = get_last_error();
+                        boost::asio::post(
+                                _strand,
+                                [pid_res, ec, h]
+                                {
+                                    h(pid_res, ec);
+                                });
+                    }
                     else if ((pid_res == pid) && (WIFEXITED(status) || WIFSIGNALED(status)))
-                        h(status, {}); //successfully exited already
+                        boost::asio::post(
+                                _strand,
+                                [status, h]
+                                {
+                                    h(status, {}); //successfully exited already
+                                });
                     else //still running
                     {
                         if (_receivers.empty())

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

@@ -13,6 +13,7 @@
 #include <boost/process/detail/posix/handler.hpp>
 #include <string>
 #include <unistd.h>
+#include <boost/core/ignore_unused.hpp>
 
 namespace boost { namespace process { namespace detail { namespace posix {
 
@@ -21,12 +22,12 @@ struct start_dir_init : handler_base_ext
 {
     typedef Char value_type;
     typedef std::basic_string<value_type> string_type;
-    start_dir_init(const string_type &s) : s_(s) {}
+    start_dir_init(string_type s) : s_(std::move(s)) {}
 
     template <class PosixExecutor>
     void on_exec_setup(PosixExecutor&) const
     {
-        ::chdir(s_.c_str());
+        boost::ignore_unused(::chdir(s_.c_str()));
     }
     const string_type & str() const {return s_;}
 private:

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

@@ -27,7 +27,7 @@ inline void terminate(const child_handle &p, std::error_code &ec) noexcept
         ec.clear();
 
     int status;
-    ::waitpid(p.pid, &status, WNOHANG); //just to clean it up
+    ::waitpid(p.pid, &status, 0); //should not be WNOHANG, since that would allow zombies.
 }
 
 inline void terminate(const child_handle &p)

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

@@ -158,7 +158,7 @@ inline bool wait_until(
         {
             int res;
             ::kill(pid, SIGKILL);
-            ::waitpid(pid, &res, WNOHANG);
+            ::waitpid(pid, &res, 0);
         }
     };
     child_cleaner_t child_cleaner{timeout_pid};

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

@@ -64,79 +64,9 @@ inline bool wait_until(
     bool timed_out = false;
     int ret;
 
-#if defined(BOOST_POSIX_HAS_SIGTIMEDWAIT)
-    auto get_timespec =
-            +[](const Duration & dur)
-            {
-                ::timespec ts;
-                ts.tv_sec  = std::chrono::duration_cast<std::chrono::seconds>(dur).count();
-                ts.tv_nsec = std::chrono::duration_cast<std::chrono::nanoseconds>(dur).count() % 1000000000;
-                return ts;
-            };
-
-    ::sigset_t  sigset;
-
-    if (sigemptyset(&sigset) != 0)
-    {
-        ec = get_last_error();
-        return false;
-    }
-    if (sigaddset(&sigset, SIGCHLD) != 0)
-    {
-        ec = get_last_error();
-        return false;
-    }
-
-    struct ::sigaction old_sig;
-    if (-1 == ::sigaction(SIGCHLD, nullptr, &old_sig))
-    {
-        ec = get_last_error();
-        return false;
-    }
-
-    do
-    {
-        auto ts = get_timespec(time_out - Clock::now());
-        ret = ::sigtimedwait(&sigset, nullptr, &ts);
-        errno = 0;
-        if ((ret == SIGCHLD) && (old_sig.sa_handler != SIG_DFL) && (old_sig.sa_handler != SIG_IGN))
-            old_sig.sa_handler(ret);
-
-        ret = ::waitpid(-p.grp, &siginfo.si_status, 0); //so in case it exited, we wanna reap it first
-        if (ret == -1)
-        {
-			if ((errno == ECHILD) || (errno == ESRCH))
-			{
-				ec.clear();
-				return true;
-			}
-			else
-			{
-				ec = get_last_error();
-				return false; 
-			}
-        }
-
-        //check if we're done ->
-        ret = ::waitid(P_PGID, p.grp, &siginfo, WEXITED | WNOHANG);
-    }
-    while (((ret != -1) || ((errno != ECHILD) && (errno != ESRCH))) && !(timed_out = (Clock::now() > time_out)));
-
-    if (errno != ECHILD)
-    {
-        ec = boost::process::detail::get_last_error();
-        return !timed_out;
-    }
-    else
-    {
-        ec.clear();
-        return true; //even if timed out, there are no child proccessess left
-    }
-
-#else
     ::timespec sleep_interval;
     sleep_interval.tv_sec = 0;
-    sleep_interval.tv_nsec = 1000000;
+    sleep_interval.tv_nsec = 100000000;
 
 
     while (!(timed_out = (Clock::now() > time_out)))
@@ -156,7 +86,6 @@ inline bool wait_until(
         ::nanosleep(&sleep_interval, nullptr);
     }
     return !timed_out;
-#endif
 }
 
 template< class Clock, class Duration >

include/boost/process/detail/traits/cmd_or_exe.hpp

@@ -11,7 +11,7 @@
 #include <vector>
 #include <type_traits>
 #include <initializer_list>
-#include <boost/filesystem/path.hpp>
+#include <boost/process/filesystem.hpp>
 #include <boost/process/detail/traits/decl.hpp>
 namespace boost { namespace process { namespace detail {
 
@@ -53,12 +53,12 @@ template<> struct initializer_tag<std::initializer_list<const wchar_t *>> { type
 
 template<> struct initializer_tag<shell_>
 {
-    typedef cmd_or_exe_tag<typename boost::filesystem::path::value_type> type;
+    typedef cmd_or_exe_tag<typename boost::process::filesystem::path::value_type> type;
 };
 
-template<> struct initializer_tag<boost::filesystem::path>
+template<> struct initializer_tag<boost::process::filesystem::path>
 {
-    typedef cmd_or_exe_tag<typename boost::filesystem::path::value_type> type;
+    typedef cmd_or_exe_tag<typename boost::process::filesystem::path::value_type> type;
 };
 
 template <typename Char>

include/boost/process/detail/traits/wchar_t.hpp

@@ -7,6 +7,8 @@
 #ifndef BOOST_PROCESS_DETAIL_TRAITS_WCHAR_T_HPP_
 #define BOOST_PROCESS_DETAIL_TRAITS_WCHAR_T_HPP_
 
+#include <algorithm>
+
 #include <boost/process/detail/traits/decl.hpp>
 #include <boost/process/detail/traits/cmd_or_exe.hpp>
 #include <boost/process/detail/traits/env.hpp>
@@ -18,7 +20,7 @@ namespace boost { namespace process { namespace detail {
 
 template<typename T> struct is_wchar_t : std::false_type {};
 
-template<> struct is_wchar_t<boost::filesystem::path> : std::is_same<typename boost::filesystem::path::value_type, wchar_t>
+template<> struct is_wchar_t<boost::process::filesystem::path> : std::is_same<typename boost::process::filesystem::path::value_type, wchar_t>
 {
 };
 

include/boost/process/detail/used_handles.hpp

@@ -69,7 +69,7 @@ template<typename Executor>
 std::vector<::boost::process::detail::api::native_handle_type>
         get_used_handles(Executor &exec)
 {
-    std::vector<::boost::process::detail::api::native_handle_type> res;
+    std::vector<::boost::process::detail::api::native_handle_type> res = exec.get_used_handles();
     foreach_used_handle(exec, [&](::boost::process::detail::api::native_handle_type handle){res.push_back(handle);});
     return res;
 }

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

@@ -7,6 +7,7 @@
 #define BOOST_PROCESS_DETAIL_WINDOWS_ASIO_FWD_HPP_
 
 #include <memory>
+#include <boost/asio/ts/netfwd.hpp>
 
 namespace boost { namespace asio {
 
@@ -19,43 +20,19 @@ template<typename Allocator>
 class basic_streambuf;
 
 typedef basic_streambuf<std::allocator<char>> streambuf;
-class io_context;
-
-class executor;
-
 
 template <typename Handler>
 class basic_yield_context;
 
 namespace windows {
 
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class stream_handle_service;
-
-template <typename StreamHandleService>
-class basic_stream_handle;
-
-typedef basic_stream_handle<stream_handle_service> stream_handle;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_stream_handle;
-typedef basic_stream_handle<executor> stream_handle;
+typedef basic_stream_handle<any_io_executor> stream_handle;
 
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
-
-
-#if defined(BOOST_ASIO_ENABLE_OLD_SERVICES)
-class object_handle_service;
-
-template <typename ObjectHandleService>
-class basic_object_handle;
-
-typedef basic_object_handle<object_handle_service> object_handle;
-#else /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
 template <typename Executor>
 class basic_object_handle;
-typedef basic_object_handle<executor> object_handle;
-#endif /* defined(BOOST_ASIO_ENABLE_OLD_SERVICES) */
+typedef basic_object_handle<any_io_executor> object_handle;
 
 } //windows
 } //asio

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

@@ -48,6 +48,7 @@ class async_pipe
 public:
     typedef ::boost::winapi::HANDLE_ native_handle_type;
     typedef ::boost::asio::windows::stream_handle   handle_type;
+    typedef typename handle_type::executor_type executor_type;
 
     async_pipe(boost::asio::io_context & ios) : async_pipe(ios, ios, make_pipe_name(), true) {}
     async_pipe(boost::asio::io_context & ios_source, boost::asio::io_context & ios_sink)

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

@@ -30,14 +30,17 @@ inline std::string build_args(const std::string & exe, std::vector<std::string>
 {
     std::string st = exe;
 
-    //put in quotes if it has spaces
+    //put in quotes if it has spaces or double quotes
+    if(!exe.empty())
     {
-        boost::replace_all(st, "\"", "\\\"");
+        auto it = st.find_first_of(" \"");
 
-        auto it = std::find(st.begin(), st.end(), ' ');
-
-        if (it != st.end())//contains spaces.
+        if(it != st.npos)//contains spaces.
         {
+            // double existing quotes
+            boost::replace_all(st, "\"", "\"\"");
+
+            // surround with quotes
             st.insert(st.begin(), '"');
             st += '"';
         }
@@ -45,15 +48,18 @@ inline std::string build_args(const std::string & exe, std::vector<std::string>
 
     for (auto & arg : data)
     {
-        boost::replace_all(arg, "\"", "\\\"");
-
-        auto it = std::find(arg.begin(), arg.end(), ' ');//contains space?
-        if (it != arg.end())//ok, contains spaces.
+        if(!arg.empty())
         {
-            //the first one is put directly onto the output,
-            //because then I don't have to copy the whole string
-            arg.insert(arg.begin(), '"');
-            arg += '"'; //thats the post one.
+            auto it = arg.find_first_of(" \"");//contains space or double quotes?
+            if(it != arg.npos)//yes
+            {
+                // double existing quotes
+                boost::replace_all(arg, "\"", "\"\"");
+
+                // surround with quotes
+                arg.insert(arg.begin(), '"');
+                arg += '"';
+            }
         }
 
         if (!st.empty())//first one does not need a preceeding space
@@ -68,30 +74,36 @@ inline std::wstring build_args(const std::wstring & exe, std::vector<std::wstrin
 {
     std::wstring st = exe;
 
-    //put in quotes if it has spaces
+    //put in quotes if it has spaces or double quotes
+    if(!exe.empty())
     {
-        boost::replace_all(st, L"\"", L"\\\"");
+        auto it = st.find_first_of(L" \"");
 
-        auto it = std::find(st.begin(), st.end(), L' ');
-
-        if (it != st.end())//contains spaces.
+        if(it != st.npos)//contains spaces or double quotes.
         {
+            // double existing quotes
+            boost::replace_all(st, L"\"", L"\"\"");
+
+            // surround with quotes
             st.insert(st.begin(), L'"');
             st += L'"';
         }
     }
 
-    for (auto & arg : data)
+    for(auto & arg : data)
     {
-        boost::replace_all(arg, L"\"", L"\\\"");
-
-        auto it = std::find(arg.begin(), arg.end(), L' ');//contains space?
-        if (it != arg.end())//ok, contains spaces.
+        if(!arg.empty())
         {
-            //the first one is put directly onto the output,
-            //because then I don't have to copy the whole string
-            arg.insert(arg.begin(), L'"');
-            arg += L'"'; //thats the post one.
+            auto it = arg.find_first_of(L" \"");//contains space or double quotes?
+            if(it != arg.npos)//yes
+            {
+                // double existing quotes
+                boost::replace_all(arg, L"\"", L"\"\"");
+
+                // surround with quotes
+                arg.insert(arg.begin(), L'"');
+                arg += '"';
+            }
         }
 
         if (!st.empty())//first one does not need a preceeding space

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

@@ -17,7 +17,7 @@
 
 namespace boost { namespace process { namespace detail { namespace windows {
 
-typedef int pid_t;
+typedef ::boost::winapi::DWORD_ pid_t;
 
 struct child_handle
 {
@@ -66,7 +66,7 @@ struct child_handle
 
     pid_t id() const
     {
-        return static_cast<int>(proc_info.dwProcessId);
+        return static_cast<pid_t>(proc_info.dwProcessId);
     }
 
     typedef ::boost::winapi::HANDLE_ process_handle_t;

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

@@ -232,6 +232,8 @@ basic_environment_impl<Char>::basic_environment_impl(const native_environment_im
 template<typename Char>
 inline auto basic_environment_impl<Char>::get(const string_type &id) -> string_type
 {
+    if (id.size() >= _data.size()) //ok, so it's impossible id is in there.
+        return string_type(_data.data());
 
     if (std::equal(id.begin(), id.end(), _data.begin()) && (_data[id.size()] == equal_sign<Char>()))
         return string_type(_data.data()); //null-char is handled by the string.

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

@@ -10,7 +10,8 @@
 #include <boost/winapi/handles.hpp>
 #include <boost/winapi/file_management.hpp>
 #include <string>
-#include <boost/filesystem/path.hpp>
+#include <boost/process/filesystem.hpp>
+#include <boost/core/exchange.hpp>
 
 namespace boost { namespace process { namespace detail { namespace windows {
 
@@ -39,7 +40,7 @@ struct file_descriptor
     }
 
     file_descriptor() = default;
-    file_descriptor(const boost::filesystem::path& p, mode_t mode = read_write)
+    file_descriptor(const boost::process::filesystem::path& p, mode_t mode = read_write)
         : file_descriptor(p.native(), mode)
     {
     }
@@ -90,10 +91,19 @@ struct file_descriptor
 
 }
     file_descriptor(const file_descriptor & ) = delete;
-    file_descriptor(file_descriptor && ) = default;
+    file_descriptor(file_descriptor &&other)
+        : _handle( boost::exchange(other._handle, ::boost::winapi::INVALID_HANDLE_VALUE_) )
+    {
+    }
 
     file_descriptor& operator=(const file_descriptor & ) = delete;
-    file_descriptor& operator=(file_descriptor && ) = default;
+    file_descriptor& operator=(file_descriptor &&other)
+    {
+        if (_handle != ::boost::winapi::INVALID_HANDLE_VALUE_)
+            ::boost::winapi::CloseHandle(_handle);
+        _handle = boost::exchange(other._handle, ::boost::winapi::INVALID_HANDLE_VALUE_);
+        return *this;
+    }
 
     ~file_descriptor()
     {

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

@@ -12,7 +12,7 @@
 //#define BOOST_USE_WINDOWS_H 1
 
 #if defined( BOOST_USE_WINDOWS_H )
-#include <Winternl.h>
+#include <winternl.h>
 #endif
 
 
@@ -198,20 +198,20 @@ typedef struct _OBJECT_TYPE_INFORMATION_ {
 
 
 /*
-__kernel_entry NTSTATUS NtQuerySystemInformation(
+NTSTATUS NtQuerySystemInformation(
   IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
   OUT PVOID                   SystemInformation,
   IN ULONG                    SystemInformationLength,
   OUT PULONG                  ReturnLength
 );
  */
-typedef ::boost::winapi::NTSTATUS_ (__kernel_entry *nt_system_query_information_p )(
+typedef ::boost::winapi::NTSTATUS_ (*nt_system_query_information_p )(
         SYSTEM_INFORMATION_CLASS_,
         void *,
         ::boost::winapi::ULONG_,
         ::boost::winapi::PULONG_);
 /*
-__kernel_entry NTSYSCALLAPI NTSTATUS NtQueryObject(
+NTSYSCALLAPI NTSTATUS NtQueryObject(
   HANDLE                   Handle,
   OBJECT_INFORMATION_CLASS ObjectInformationClass,
   PVOID                    ObjectInformation,
@@ -220,7 +220,7 @@ __kernel_entry NTSYSCALLAPI NTSTATUS NtQueryObject(
 );
  */
 
-typedef ::boost::winapi::NTSTATUS_ (__kernel_entry *nt_query_object_p )(
+typedef ::boost::winapi::NTSTATUS_ (*nt_query_object_p )(
         ::boost::winapi::HANDLE_,
         OBJECT_INFORMATION_CLASS_,
         void *,

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

@@ -11,6 +11,7 @@
 #include <boost/process/detail/windows/handle_workaround.hpp>
 #include <boost/process/detail/windows/handler.hpp>
 #include <boost/winapi/get_current_process_id.hpp>
+#include <boost/winapi/handles.hpp>
 
 namespace boost { namespace process { namespace detail {
 
@@ -34,12 +35,12 @@ inline std::vector<native_handle_type> get_handles(std::error_code & ec)
 
     ::boost::winapi::NTSTATUS_ nt_status = STATUS_INFO_LENGTH_MISMATCH_;
 
-    for (int cnt = 0;
+    for (;
            nt_status == STATUS_INFO_LENGTH_MISMATCH_;
            nt_status = workaround::nt_system_query_information(
                             workaround::SystemHandleInformation_,
-                            info_pointer, buffer.size(),
-                            NULL))
+                            info_pointer, static_cast<::boost::winapi::ULONG_>(buffer.size()),
+                            nullptr))
     {
         buffer.resize(buffer.size() * 2);
         info_pointer = reinterpret_cast<workaround::SYSTEM_HANDLE_INFORMATION_*>(buffer.data());
@@ -136,7 +137,7 @@ struct limit_handles_ : handler_base_ext
                 [&](::boost::winapi::HANDLE_ handle)
                 {
                     auto itr = std::find(all_handles.begin(), all_handles .end(), handle);
-                    DWORD flags = 0u;
+                    ::boost::winapi::DWORD_ flags = 0u;
                     if (itr != all_handles.end())
                         *itr = ::boost::winapi::INVALID_HANDLE_VALUE_;
                     else if ((::boost::winapi::GetHandleInformation(*itr, &flags) != 0)

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

@@ -8,7 +8,9 @@
 
 #include <boost/process/detail/handler_base.hpp>
 #include <boost/process/detail/windows/async_handler.hpp>
+#include <boost/process/detail/windows/is_running.hpp>
 #include <boost/asio/io_context.hpp>
+#include <boost/asio/post.hpp>
 #include <boost/asio/windows/object_handle.hpp>
 #include <boost/winapi/process.hpp>
 #include <boost/winapi/handles.hpp>
@@ -114,6 +116,15 @@ struct io_context_ref : boost::process::detail::handler_base
 
         wait_handler wh(std::move(funcs), ios, process_handle, exec.exit_status);
 
+        ::boost::winapi::DWORD_ code;
+        if(::boost::winapi::GetExitCodeProcess(process_handle, &code)
+            && code != still_active)
+        {
+            ::boost::asio::post(wh.handle->get_executor(), std::move(wh));
+            return;
+        }
+
+
         auto handle_p = wh.handle.get();
         handle_p->async_wait(std::move(wh));
     }
@@ -130,12 +141,13 @@ struct io_context_ref : boost::process::detail::handler_base
                      boost::asio::io_context & ios, void * handle,
                      const std::shared_ptr<std::atomic<int>> &exit_status)
                 : funcs(std::move(funcs)),
-                  handle(new boost::asio::windows::object_handle(ios.get_executor(), handle)),
+                  handle(new boost::asio::windows::object_handle(
+                          asio::prefer(ios.get_executor(), asio::execution::outstanding_work.tracked), handle)),
                   exit_status(exit_status)
         {
 
         }
-        void operator()(const boost::system::error_code & ec_in)
+        void operator()(const boost::system::error_code & ec_in = {})
         {
             std::error_code ec;
             if (ec_in)

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

@@ -1,4 +1,4 @@
-// Copyright (c) 2106 Klemens D. Morgenstern
+// Copyright (c) 2016 Klemens D. Morgenstern
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,6 +7,7 @@
 #define BOOST_PROCESS_WINDOWS_IS_RUNNING_HPP
 
 #include <boost/process/detail/config.hpp>
+#include <boost/process/detail/windows/child_handle.hpp>
 #include <system_error>
 #include <cstdlib>
 #include <boost/winapi/process.hpp>

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

@@ -6,13 +6,20 @@
 #ifndef BOOST_PROCESS_WINDOWS_ON_EXIT_HPP_
 #define BOOST_PROCESS_WINDOWS_ON_EXIT_HPP_
 
+#include <boost/process/async.hpp>
 #include <boost/process/detail/config.hpp>
 #include <boost/process/detail/handler_base.hpp>
 #include <boost/process/detail/windows/async_handler.hpp>
+#include <boost/asio/execution.hpp>
 #include <system_error>
 #include <functional>
 
-namespace boost { namespace process { namespace detail { namespace windows {
+namespace boost { namespace process { namespace detail {
+
+template<typename Tuple>
+inline asio::io_context& get_io_context(const Tuple & tup);
+
+namespace windows {
 
 struct on_exit_ : boost::process::detail::windows::async_handler
 {
@@ -23,10 +30,12 @@ struct on_exit_ : boost::process::detail::windows::async_handler
     }
 
     template<typename Executor>
-    std::function<void(int, const std::error_code&)> on_exit_handler(Executor&)
+    std::function<void(int, const std::error_code&)> on_exit_handler(Executor& exec)
     {
+        auto v = boost::asio::prefer(boost::process::detail::get_io_context(exec.seq).get_executor(),
+                                     boost::asio::execution::outstanding_work.tracked);
         auto handler_ = this->handler;
-        return [handler_](int exit_code, const std::error_code & ec)
+        return [v, handler_](int exit_code, const std::error_code & ec)
                {
                     handler_(static_cast<int>(exit_code), ec);
                };

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

@@ -11,8 +11,7 @@
 #define BOOST_PROCESS_WINDOWS_SEARCH_PATH_HPP
 
 #include <boost/process/detail/config.hpp>
-#include <boost/filesystem/path.hpp>
-#include <boost/filesystem/operations.hpp>
+#include <boost/process/filesystem.hpp>
 #include <boost/system/error_code.hpp>
 #include <string>
 #include <stdexcept>
@@ -24,9 +23,9 @@
 
 namespace boost { namespace process { namespace detail { namespace windows {
 
-inline boost::filesystem::path search_path(
-        const boost::filesystem::path &filename,
-        const std::vector<boost::filesystem::path> &path)
+inline boost::process::filesystem::path search_path(
+        const boost::process::filesystem::path &filename,
+        const std::vector<boost::process::filesystem::path> &path)
 {
     const ::boost::process::wnative_environment ne{};
     typedef typename ::boost::process::wnative_environment::const_entry_type value_type;
@@ -55,19 +54,19 @@ inline boost::filesystem::path search_path(
     for (auto & ext : extensions)
         boost::to_lower(ext);
 
-    for (const boost::filesystem::path & pp_ : path)
+    for (const boost::process::filesystem::path & pp_ : path)
     {
         auto p = pp_ / filename;
-        for (boost::filesystem::path ext : extensions)
+        for (boost::process::filesystem::path ext : extensions)
         {
-            boost::filesystem::path pp = p;
-            pp += ext;
+            boost::process::filesystem::path pp_ext = p;
+            pp_ext += ext;
             boost::system::error_code ec;
-            bool file = boost::filesystem::is_regular_file(pp, ec);
+            bool file = boost::process::filesystem::is_regular_file(pp_ext, ec);
             if (!ec && file &&
-                ::boost::winapi::sh_get_file_info(pp.native().c_str(), 0, 0, 0, ::boost::winapi::SHGFI_EXETYPE_))
+                ::boost::winapi::sh_get_file_info(pp_ext.native().c_str(), 0, 0, 0, ::boost::winapi::SHGFI_EXETYPE_))
             {
-                return pp;
+                return pp_ext;
             }
         }
     }

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

@@ -12,29 +12,29 @@
 
 #include <boost/process/detail/config.hpp>
 #include <system_error>
-#include <boost/filesystem/path.hpp>
+#include <boost/process/filesystem.hpp>
 #include <boost/winapi/basic_types.hpp>
 #include <boost/winapi/get_system_directory.hpp>
 
 namespace boost { namespace process { namespace detail { namespace windows {
 
-inline boost::filesystem::path shell_path()
+inline boost::process::filesystem::path shell_path()
 {
     ::boost::winapi::WCHAR_ sysdir[260];
     unsigned int size = ::boost::winapi::get_system_directory(sysdir, sizeof(sysdir));
     if (!size)
         throw_last_error("GetSystemDirectory() failed");
 
-    boost::filesystem::path p = sysdir;
+    boost::process::filesystem::path p = sysdir;
     return p / "cmd.exe";
 }
 
-inline boost::filesystem::path shell_path(std::error_code &ec) noexcept
+inline boost::process::filesystem::path shell_path(std::error_code &ec) noexcept
 {
 
     ::boost::winapi::WCHAR_ sysdir[260];
     unsigned int size = ::boost::winapi::get_system_directory(sysdir, sizeof(sysdir));
-    boost::filesystem::path p;
+    boost::process::filesystem::path p;
     if (!size)
         ec = std::error_code(
                 ::boost::winapi::GetLastError(),

include/boost/process/env.hpp

@@ -6,6 +6,7 @@
 #ifndef BOOST_PROCESS_DETAIL_ENV_HPP_
 #define BOOST_PROCESS_DETAIL_ENV_HPP_
 
+#include <boost/process/detail/traits/wchar_t.hpp>
 #include <boost/process/environment.hpp>
 #include <boost/none.hpp>
 

include/boost/process/environment.hpp

@@ -11,7 +11,7 @@
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/iterator/transform_iterator.hpp>
-#include <boost/filesystem/path.hpp>
+#include <boost/process/filesystem.hpp>
 
 #if defined(BOOST_POSIX_API)
 #include <boost/process/detail/posix/environment.hpp>
@@ -44,7 +44,7 @@ struct const_entry
             bool operator()(char c)    const {return c == api::env_seperator<char>   ();}
         } s;
         boost::split(data, _data, s);
-        return std::move(data);
+        return data;
     }
     string_type to_string()              const
     {
@@ -263,7 +263,9 @@ public:
         auto st1 = key + ::boost::process::detail::equal_sign<Char>();
         while (*p != nullptr)
         {
-            if (std::equal(st1.begin(), st1.end(), *p))
+            const int len = std::char_traits<Char>::length(*p);
+            if ((std::distance(st1.begin(), st1.end()) < len)
+                 && std::equal(st1.begin(), st1.end(), *p))
                 break;
             p++;
         }
@@ -275,7 +277,9 @@ public:
         auto st1 = key + ::boost::process::detail::equal_sign<Char>();
         while (*p != nullptr)
         {
-            if (std::equal(st1.begin(), st1.end(), *p))
+            const int len = std::char_traits<Char>::length(*p);
+            if ((std::distance(st1.begin(), st1.end()) < len)
+                && std::equal(st1.begin(), st1.end(), *p))
                 break;
             p++;
         }
@@ -288,7 +292,9 @@ public:
         auto st1 = st + ::boost::process::detail::equal_sign<Char>();
         while (*p != nullptr)
         {
-            if (std::equal(st1.begin(), st1.end(), *p))
+            const int len = std::char_traits<Char>::length(*p);
+            if ((std::distance(st1.begin(), st1.end()) < len)
+                && std::equal(st1.begin(), st1.end(), *p))
                 return 1u;
             p++;
         }
@@ -672,16 +678,16 @@ inline native_environment   environment() { return ::boost::process:: native_env
 ///Get the enviroment of the current process.
 inline wnative_environment wenvironment() { return ::boost::process::wnative_environment(); }
 ///Get the path environment variable of the current process runs.
-inline std::vector<boost::filesystem::path> path()
+inline std::vector<boost::process::filesystem::path> path()
 {
 #if defined(BOOST_WINDOWS_API)
     const ::boost::process::wnative_environment ne{};
     typedef typename ::boost::process::wnative_environment::const_entry_type value_type;
-    const auto id = L"PATH";
+    static constexpr auto id = L"PATH";
 #else
     const ::boost::process::native_environment ne{};
     typedef typename ::boost::process::native_environment::const_entry_type value_type;
-    const auto id = "PATH";
+    static constexpr auto id = "PATH";
 #endif
 
     auto itr = std::find_if(ne.cbegin(), ne.cend(),
@@ -693,7 +699,7 @@ inline std::vector<boost::filesystem::path> path()
 
     auto vec = itr->to_vector();
 
-    std::vector<boost::filesystem::path> val;
+    std::vector<boost::process::filesystem::path> val;
     val.resize(vec.size());
 
     std::copy(vec.begin(), vec.end(), val.begin());

include/boost/process/error.hpp

@@ -59,7 +59,7 @@ namespace detail {
 
 struct throw_on_error_ : ::boost::process::detail::api::handler_base_ext
 {
-    constexpr throw_on_error_() {};
+    constexpr throw_on_error_() = default;
 
     template <class Executor>
     void on_error(Executor&, const std::error_code & ec) const
@@ -72,7 +72,7 @@ struct throw_on_error_ : ::boost::process::detail::api::handler_base_ext
 
 struct ignore_error_ : ::boost::process::detail::api::handler_base_ext
 {
-    constexpr ignore_error_() {};
+    constexpr ignore_error_() = default;
 };
 
 struct set_on_error : ::boost::process::detail::api::handler_base_ext
@@ -81,7 +81,7 @@ struct set_on_error : ::boost::process::detail::api::handler_base_ext
     explicit set_on_error(std::error_code &ec) : ec_(ec) {}
 
     template <class Executor>
-    void on_error(Executor&, const std::error_code & ec) const
+    void on_error(Executor&, const std::error_code & ec) const noexcept
     {
         ec_ = ec;
     }
@@ -92,7 +92,7 @@ private:
 
 struct error_
 {
-    constexpr error_() {}
+    constexpr error_() = default;
     set_on_error operator()(std::error_code &ec) const {return set_on_error(ec);}
     set_on_error operator= (std::error_code &ec) const {return set_on_error(ec);}
 

include/boost/process/exe.hpp

@@ -36,15 +36,15 @@ namespace detail {
 struct exe_
 {
     template<typename = void>
-    inline exe_setter_<typename boost::filesystem::path::value_type> operator()(const boost::filesystem::path & pth) const
+    inline exe_setter_<typename boost::process::filesystem::path::value_type> operator()(const boost::process::filesystem::path & pth) const
     {
-        return exe_setter_<typename boost::filesystem::path::value_type>(pth.native());
+        return exe_setter_<typename boost::process::filesystem::path::value_type>(pth.native());
     }
 
     template<typename = void>
-    inline exe_setter_<typename boost::filesystem::path::value_type> operator=(const boost::filesystem::path & pth) const
+    inline exe_setter_<typename boost::process::filesystem::path::value_type> operator=(const boost::process::filesystem::path & pth) const
     {
-        return exe_setter_<typename boost::filesystem::path::value_type>(pth.native());
+        return exe_setter_<typename boost::process::filesystem::path::value_type>(pth.native());
     }
 
 
@@ -79,7 +79,7 @@ The overload form applies when to the first, when several strings are passed to
 function.
 
 The following expressions are valid, with `value` being either a C-String or
-a `std::basic_string` with `char` or `wchar_t` or a `boost::filesystem::path`.
+a `std::basic_string` with `char` or `wchar_t` or a `boost::process::filesystem::path`.
 
 \code{.cpp}
 exe="value";

include/boost/process/extend.hpp

@@ -8,6 +8,7 @@
 
 #include <boost/process/detail/handler.hpp>
 #include <boost/process/detail/used_handles.hpp>
+#include <memory>
 
 #if defined(BOOST_WINDOWS_API)
 #include <boost/process/detail/windows/executor.hpp>

include/boost/process/filesystem.hpp

@@ -0,0 +1,28 @@
+// Copyright (c) 2021 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_FILESYSTEM_HPP
+#define BOOST_PROCESS_FILESYSTEM_HPP
+
+#ifdef BOOST_PROCESS_USE_STD_FS
+#include <filesystem>
+#else
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#endif
+
+namespace boost
+{
+namespace process
+{
+#ifdef BOOST_PROCESS_USE_STD_FS
+namespace filesystem = std::filesystem;
+#else
+namespace filesystem = boost::filesystem;
+#endif
+
+}
+}
+
+#endif //BOOST_PROCESS_FILESYSTEM_HPP

include/boost/process/io.hpp

@@ -60,9 +60,9 @@ namespace boost {
 The library allows full redirection of streams to files as shown below.
 
 \code{.cpp}
-boost::filesystem::path log    = "my_log_file.txt";
-boost::filesystem::path input  = "input.txt";
-boost::filesystem::path output = "output.txt";
+boost::process::filesystem::path log    = "my_log_file.txt";
+boost::process::filesystem::path input  = "input.txt";
+boost::process::filesystem::path output = "output.txt";
 system("my_prog", std_out>output, std_in<input, std_err>log);
 \endcode
 
@@ -136,13 +136,13 @@ template<typename T> using is_mutable_buffer =
         >;
 
 
-struct null_t  {constexpr null_t() {}};
+struct null_t  {constexpr null_t() = default;};
 struct close_t;
 
 template<class>
 struct std_in_
 {
-    constexpr std_in_() {}
+    constexpr std_in_() = default;
 
     api::close_in close() const {return api::close_in(); }
     api::close_in operator=(const close_t &) const {return api::close_in();}
@@ -152,13 +152,13 @@ struct std_in_
     api::null_in operator=(const null_t &) const {return api::null_in();}
     api::null_in operator<(const null_t &) const {return api::null_in();}
 
-    api::file_in operator=(const boost::filesystem::path &p) const {return p;}
+    api::file_in operator=(const boost::process::filesystem::path &p) const {return p;}
     api::file_in operator=(const std::string & p)            const {return p;}
     api::file_in operator=(const std::wstring &p)            const {return p;}
     api::file_in operator=(const char * p)                   const {return p;}
     api::file_in operator=(const wchar_t * p)                const {return p;}
 
-    api::file_in operator<(const boost::filesystem::path &p) const {return p;}
+    api::file_in operator<(const boost::process::filesystem::path &p) const {return p;}
     api::file_in operator<(const std::string &p)             const {return p;}
     api::file_in operator<(const std::wstring &p)            const {return p;}
     api::file_in operator<(const char*p)                     const {return p;}
@@ -199,7 +199,7 @@ struct std_in_
 template<int p1, int p2 = -1>
 struct std_out_
 {
-    constexpr std_out_() {}
+    constexpr std_out_() = default;
 
     api::close_out<p1,p2> close() const {return api::close_out<p1,p2>(); }
     api::close_out<p1,p2> operator=(const close_t &) const {return api::close_out<p1,p2>();}
@@ -209,13 +209,13 @@ struct std_out_
     api::null_out<p1,p2> operator=(const null_t &) const {return api::null_out<p1,p2>();}
     api::null_out<p1,p2> operator>(const null_t &) const {return api::null_out<p1,p2>();}
 
-    api::file_out<p1,p2> operator=(const boost::filesystem::path &p) const {return api::file_out<p1,p2>(p);}
+    api::file_out<p1,p2> operator=(const boost::process::filesystem::path &p) const {return api::file_out<p1,p2>(p);}
     api::file_out<p1,p2> operator=(const std::string &p)             const {return api::file_out<p1,p2>(p);}
     api::file_out<p1,p2> operator=(const std::wstring &p)            const {return api::file_out<p1,p2>(p);}
     api::file_out<p1,p2> operator=(const char * p)                   const {return api::file_out<p1,p2>(p);}
     api::file_out<p1,p2> operator=(const wchar_t * p)                const {return api::file_out<p1,p2>(p);}
 
-    api::file_out<p1,p2> operator>(const boost::filesystem::path &p) const {return api::file_out<p1,p2>(p);}
+    api::file_out<p1,p2> operator>(const boost::process::filesystem::path &p) const {return api::file_out<p1,p2>(p);}
     api::file_out<p1,p2> operator>(const std::string &p)             const {return api::file_out<p1,p2>(p);}
     api::file_out<p1,p2> operator>(const std::wstring &p)            const {return api::file_out<p1,p2>(p);}
     api::file_out<p1,p2> operator>(const char * p)                   const {return api::file_out<p1,p2>(p);}
@@ -260,7 +260,7 @@ struct std_out_
 
 struct close_t
 {
-    constexpr close_t() {}
+    constexpr close_t() = default;
     template<int T, int U>
     api::close_out<T,U> operator()(std_out_<T,U>) {return api::close_out<T,U>();}
 };
@@ -282,7 +282,7 @@ This property allows to set the input stream for the child process.
 
 The file I/O simple redirects the stream to a file, for which the possible types are
 
- - `boost::filesystem::path`
+ - `boost::process::filesystem::path`
  - `std::basic_string<char_type>`
  - `const char_type*`
  - `FILE*`
@@ -424,7 +424,7 @@ This property allows to set the output stream for the child process.
 
 The file I/O simple redirects the stream to a file, for which the possible types are
 
- - `boost::filesystem::path`
+ - `boost::process::filesystem::path`
  - `std::basic_string<char_type>`
  - `const char_type*`
  - `FILE*`

include/boost/process/locale.hpp

@@ -28,7 +28,7 @@ namespace detail
 class codecvt_category_t : public std::error_category
 {
 public:
-    codecvt_category_t(){}
+    codecvt_category_t() = default;
     const char* name() const noexcept override {return "codecvt";}
     std::string message(int ev) const override
     {
@@ -76,9 +76,8 @@ inline std::locale default_locale()
     std::locale global_loc = std::locale();
     return std::locale(global_loc, new std::codecvt_utf8<wchar_t>);
 # else  // Other POSIX
-    // ISO C calls std::locale("") "the locale-specific native environment", and this
-    // locale is the default for many POSIX-based operating systems such as Linux.
-    return std::locale("");
+    // Return a default locale object.
+    return std::locale();
 # endif
 }
 

include/boost/process/pipe.hpp

@@ -123,8 +123,8 @@ struct basic_pipebuf : std::basic_streambuf<CharT, Traits>
     ///Destructor -> writes the frest of the data
     ~basic_pipebuf()
     {
-        if (is_open())
-            overflow(Traits::eof());
+        if (basic_pipebuf::is_open())
+            basic_pipebuf::overflow(Traits::eof());
     }
 
     ///Move construct from a pipe.
@@ -167,10 +167,12 @@ struct basic_pipebuf : std::basic_streambuf<CharT, Traits>
             if (this->pptr() == this->epptr())
             {
                 bool wr = this->_write_impl();
-                *this->pptr() = ch;
-                this->pbump(1);
                 if (wr)
+                {
+                    *this->pptr() = ch;
+                    this->pbump(1);
                     return ch;
+                }
             }
             else
             {
@@ -277,7 +279,7 @@ private:
         else if (wrt == 0) //broken pipe
             return false;
 
-        this->pbump(-wrt);
+        this->pbump(static_cast<int>(-wrt));
 
         return true;
     }
@@ -340,8 +342,9 @@ public:
     basic_ipstream& operator=(basic_ipstream && lhs)
     {
         std::basic_istream<CharT, Traits>::operator=(std::move(lhs));
-        _buf = std::move(lhs);
+        _buf = std::move(lhs._buf);
         std::basic_istream<CharT, Traits>::rdbuf(&_buf);
+        return *this;
     };
     ///Move assignment of a pipe.
     basic_ipstream& operator=(pipe_type && p)
@@ -366,7 +369,7 @@ public:
     ///Get a rvalue reference to the pipe. Qualified as rvalue.
     pipe_type &&     pipe()  &&     {return std::move(_buf).pipe();}
     ///Check if the pipe is open
-    bool is_open() const {return _buf->is_open();}
+    bool is_open() const {return _buf.is_open();}
 
     ///Open a new pipe
     void open()
@@ -448,8 +451,9 @@ public:
     basic_opstream& operator=(basic_opstream && lhs)
     {
         std::basic_ostream<CharT, Traits>::operator=(std::move(lhs));
-        _buf = std::move(lhs);
+        _buf = std::move(lhs._buf);
         std::basic_ostream<CharT, Traits>::rdbuf(&_buf);
+        return *this;
     };
 
     ///Move assignment of a pipe.
@@ -556,8 +560,9 @@ public:
     basic_pstream& operator=(basic_pstream && lhs)
     {
         std::basic_istream<CharT, Traits>::operator=(std::move(lhs));
-        _buf = std::move(lhs);
+        _buf = std::move(lhs._buf);
         std::basic_iostream<CharT, Traits>::rdbuf(&_buf);
+        return *this;
     };
     ///Move assignment of a pipe.
     basic_pstream& operator=(pipe_type && p)

include/boost/process/search_path.hpp

@@ -44,8 +44,8 @@ namespace boost { namespace process {
  * \returns the absolute path to the executable filename or an
  *          empty string if filename isn't found
  */
-inline boost::filesystem::path search_path(const boost::filesystem::path &filename,
-                                    const std::vector<boost::filesystem::path> path = ::boost::this_process::path())
+inline boost::process::filesystem::path search_path(const boost::process::filesystem::path &filename,
+                                    const std::vector<boost::process::filesystem::path> path = ::boost::this_process::path())
 {
     return ::boost::process::detail::api::search_path(filename, path);
 }

include/boost/process/shell.hpp

@@ -44,18 +44,18 @@ struct shell_
 {
     constexpr shell_() {}
 
-    boost::filesystem::path operator()() const
+    boost::process::filesystem::path operator()() const
     {
         return boost::process::detail::api::shell_path();
     }
-    boost::filesystem::path operator()(std::error_code & ec) const noexcept
+    boost::process::filesystem::path operator()(std::error_code & ec) const noexcept
     {
         return boost::process::detail::api::shell_path(ec);
     }
 };
 
 template<>
-struct is_wchar_t<shell_> : is_wchar_t<boost::filesystem::path>
+struct is_wchar_t<shell_> : is_wchar_t<boost::process::filesystem::path>
 {
 };
 

include/boost/process/start_dir.hpp

@@ -23,7 +23,7 @@
 
 #include <boost/process/detail/config.hpp>
 #include <string>
-#include <boost/filesystem/path.hpp>
+#include <boost/process/filesystem.hpp>
 
 /** \file boost/process/start_dir.hpp
  *
@@ -53,8 +53,8 @@ struct start_dir_
     api::start_dir_init<Char> operator()(std::basic_string<Char> && s) const {return {std::move(s)}; }
     template<typename Char>
     api::start_dir_init<Char> operator()(const Char* s)                const {return {s}; }
-    api::start_dir_init<typename boost::filesystem::path::value_type>
-                              operator()(const boost::filesystem::path & st) const {return {st.native()}; }
+    api::start_dir_init<typename boost::process::filesystem::path::value_type>
+                              operator()(const boost::process::filesystem::path & st) const {return {st.native()}; }
 
     template<typename Char>
     api::start_dir_init<Char> operator= (const std::basic_string<Char> & st) const {return {st}; }
@@ -62,8 +62,8 @@ struct start_dir_
     api::start_dir_init<Char> operator= (std::basic_string<Char> && s) const {return {std::move(s)}; }
     template<typename Char>
     api::start_dir_init<Char> operator= (const Char* s)                const {return {s}; }
-    api::start_dir_init<typename boost::filesystem::path::value_type>
-                              operator= (const boost::filesystem::path & st) const {return {st.native()}; }
+    api::start_dir_init<typename boost::process::filesystem::path::value_type>
+                              operator= (const boost::process::filesystem::path & st) const {return {st.native()}; }
 
 };
 
@@ -100,7 +100,7 @@ start_dir=path
 start_dir(path)
 \endcode
 
-It can be used with `std::string`, `std::wstring` and `boost::filesystem::path`.
+It can be used with `std::string`, `std::wstring` and `boost::process::filesystem::path`.
 
 
  */

include/boost/process/v2.hpp

@@ -0,0 +1,19 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_HPP
+#define BOOST_PROCESS_V2_HPP
+
+#include <boost/process/v2/error.hpp>
+#include <boost/process/v2/environment.hpp>
+#include <boost/process/v2/execute.hpp>
+#include <boost/process/v2/exit_code.hpp>
+#include <boost/process/v2/pid.hpp>
+#include <boost/process/v2/popen.hpp>
+#include <boost/process/v2/process_handle.hpp>
+#include <boost/process/v2/process.hpp>
+#include <boost/process/v2/start_dir.hpp>
+#include <boost/process/v2/stdio.hpp>
+
+#endif //BOOST_PROCESS_V2_HPP

include/boost/process/v2/cstring_ref.hpp

@@ -0,0 +1,232 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_CSTRING_REF_HPP
+#define BOOST_PROCESS_V2_CSTRING_REF_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+
+#if defined(BOOST_PROCESS_V2_STANDALONE)
+#include <string_view>
+#else
+#include <boost/utility/string_view.hpp>
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace detail
+{
+
+BOOST_CONSTEXPR static const char*     null_char_(char)     {return "";}
+BOOST_CONSTEXPR static const wchar_t*  null_char_(wchar_t)  {return L"";}
+BOOST_CONSTEXPR static const char16_t* null_char_(char16_t) {return u"";}
+BOOST_CONSTEXPR static const char32_t* null_char_(char32_t) {return U"";}
+
+#if defined(BOOST_PROCESS_V2_HAS_CHAR8_T)
+BOOST_CONSTEXPR static const char8_t* null_char_(char8_t) {return u8"";}
+#endif
+
+}
+
+#if defined(BOOST_PROCESS_V2_STANDALONE)
+using std::basic_string_view;
+using std::   string_view;
+using std::  wstring_view;
+#else
+using boost::basic_string_view;
+using boost::   string_view;
+using boost::  wstring_view;
+#endif
+
+
+/// Small wrapper for a null-terminated string that can be directly passed to C APIS
+/** This ref can only be modified by moving the front pointer. It does not store the 
+ * size, but can detect values that can directly be passed to system APIs.
+ * 
+ * It can be constructed from a `char*` pointer or any class that has a `c_str()` 
+ * member function, e.g. std::string or boost::static_string.
+ * 
+ */
+template<typename CharT, typename Traits = std::char_traits<CharT>>
+struct basic_cstring_ref
+{
+    using value_type             = CharT;
+    using traits_type            = Traits;
+
+    BOOST_CONSTEXPR basic_cstring_ref() noexcept : view_(detail::null_char_(value_type{})) {}
+    BOOST_CONSTEXPR basic_cstring_ref(std::nullptr_t) = delete;
+
+    BOOST_CONSTEXPR basic_cstring_ref( const value_type* s ) : view_(s) {}
+
+    template<typename Source,
+            typename =
+            typename std::enable_if<
+                    std::is_same<const value_type,
+                            typename std::remove_pointer<decltype(std::declval<Source>().c_str())>::type
+                    >::value>::type>
+    BOOST_CONSTEXPR basic_cstring_ref(Source && src) : view_(src.c_str()) {}
+
+    BOOST_CONSTEXPR typename basic_string_view<value_type, Traits>::const_pointer c_str() const BOOST_NOEXCEPT
+    {
+        return this->data();
+    }
+
+    using string_view_type = basic_string_view<value_type, Traits>;
+    constexpr operator string_view_type() const {return view_;}
+
+    using pointer                =       CharT *;
+    using const_pointer          = const CharT *;
+    using reference              =       CharT &;
+    using const_reference        = const CharT &;
+    using const_iterator         = const_pointer;
+    using iterator               = const_iterator;
+    using const_reverse_iterator = typename std::reverse_iterator<const_iterator>;
+    using reverse_iterator       = typename std::reverse_iterator<iterator>;
+    using size_type              = std::size_t;
+    using difference_type        = std::ptrdiff_t;
+
+    static BOOST_CONSTEXPR size_type npos = -1;
+
+    BOOST_CONSTEXPR const_iterator begin()  const BOOST_NOEXCEPT {return view_;};
+    BOOST_CONSTEXPR const_iterator end()    const BOOST_NOEXCEPT {return view_ + length();};
+    BOOST_CONSTEXPR const_iterator cbegin() const BOOST_NOEXCEPT {return view_;};
+    BOOST_CONSTEXPR const_iterator cend()   const BOOST_NOEXCEPT {return view_ + length();};
+    BOOST_CONSTEXPR const_reverse_iterator rbegin()  const BOOST_NOEXCEPT {return reverse_iterator(view_ + length());};
+    BOOST_CONSTEXPR const_reverse_iterator rend()    const BOOST_NOEXCEPT {return reverse_iterator(view_);};
+    BOOST_CONSTEXPR const_reverse_iterator crbegin() const BOOST_NOEXCEPT {return reverse_iterator(view_ + length());};
+    BOOST_CONSTEXPR const_reverse_iterator crend()   const BOOST_NOEXCEPT {return reverse_iterator(view_);};
+
+    BOOST_CONSTEXPR size_type size() const BOOST_NOEXCEPT {return length(); }
+    BOOST_CONSTEXPR size_type length() const BOOST_NOEXCEPT {return traits_type::length(view_); }
+    BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT {return (std::numeric_limits<std::size_t>::max)() / sizeof(CharT); }
+    BOOST_ATTRIBUTE_NODISCARD BOOST_CONSTEXPR bool empty() const BOOST_NOEXCEPT {return *view_ == *detail::null_char_(CharT{}); }
+
+    BOOST_CONSTEXPR const_reference operator[](size_type pos) const  {return view_[pos] ;}
+    BOOST_CXX14_CONSTEXPR const_reference at(size_type pos) const
+    {
+        if (pos >= size())
+            throw std::out_of_range("cstring-view out of range");
+        return view_[pos];
+    }
+    BOOST_CONSTEXPR const_reference front() const  {return *view_;}
+    BOOST_CONSTEXPR const_reference back()  const  {return view_[length() - 1];}
+    BOOST_CONSTEXPR const_pointer data()    const BOOST_NOEXCEPT  {return view_;}
+    BOOST_CXX14_CONSTEXPR void remove_prefix(size_type n)  {view_ = view_ + n;}
+    void swap(basic_cstring_ref& s) BOOST_NOEXCEPT {std::swap(view_, s.view_);}
+
+    size_type copy(value_type* s, size_type n, size_type pos = 0) const
+    {
+        return traits_type::copy(s, view_ + pos, n) - view_;
+    }
+    BOOST_CONSTEXPR basic_cstring_ref substr(size_type pos = 0) const
+    {
+        return basic_cstring_ref(view_ + pos);
+    }
+
+    BOOST_CONSTEXPR string_view_type substr(size_type pos, size_type length) const
+    {
+        return string_view_type(view_).substr(pos, length);
+    }
+
+    BOOST_CXX14_CONSTEXPR int compare(basic_cstring_ref x) const BOOST_NOEXCEPT
+    {
+        auto idx = 0u;
+        for (; view_[idx] != null_char_()[0] && x[idx] != null_char_()[0]; idx++)
+            if (!traits_type::eq(view_[idx], x[idx]))
+                return traits_type::lt(view_[idx], x[idx]) ? -1 : 1;
+
+        return traits_type::to_int_type(view_[idx]) -
+               traits_type::to_int_type(x[idx]); // will compare to null char of either.
+    }
+
+    BOOST_CXX14_CONSTEXPR bool starts_with(string_view_type x) const BOOST_NOEXCEPT
+    {
+        if (x.empty())
+            return true;
+
+        auto idx = 0u;
+        for (; view_[idx] != null_char_()[0] && idx < x.size(); idx++)
+            if (!traits_type::eq(view_[idx], x[idx]))
+                return false;
+
+        return idx == x.size() || view_[idx] != null_char_()[0];
+    }
+    BOOST_CONSTEXPR bool starts_with(value_type x)       const BOOST_NOEXCEPT
+    {
+        return traits_type::eq(view_[0], x);
+    }
+
+    BOOST_CXX14_CONSTEXPR size_type find( CharT ch, size_type pos = 0 ) const BOOST_NOEXCEPT
+    {
+        for (auto p = view_ + pos; *p != *null_char_(); p++)
+            if (traits_type::eq(*p, ch))
+                return p - view_;
+        return npos;
+    }
+
+
+    friend BOOST_CXX14_CONSTEXPR bool operator==(basic_cstring_ref x, basic_cstring_ref y) BOOST_NOEXCEPT
+    {
+        std::size_t idx = 0u;
+        for (idx = 0u; x[idx] != null_char_()[0] && y[idx] != null_char_()[0]; idx++)
+            if (!traits_type::eq(x[idx], y[idx]))
+                return false;
+        return x[idx] == y[idx];
+    }
+    friend BOOST_CXX14_CONSTEXPR bool operator!=(basic_cstring_ref x, basic_cstring_ref y) BOOST_NOEXCEPT
+    {
+        std::size_t idx = 0u;
+        for (idx = 0u; x[idx] != null_char_()[0] &&
+                       y[idx] != null_char_()[0]; idx++)
+            if (!traits_type::eq(x[idx], y[idx]))
+                return true;
+        return x[idx] != y[idx];
+    }
+    friend BOOST_CXX14_CONSTEXPR bool operator< (basic_cstring_ref x, basic_cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) <  0;}
+    friend BOOST_CXX14_CONSTEXPR bool operator> (basic_cstring_ref x, basic_cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) >  0;}
+    friend BOOST_CXX14_CONSTEXPR bool operator<=(basic_cstring_ref x, basic_cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) <= 0;}
+    friend BOOST_CXX14_CONSTEXPR bool operator>=(basic_cstring_ref x, basic_cstring_ref y) BOOST_NOEXCEPT {return x.compare(y) >= 0;}
+
+    // modifiers
+    void clear() BOOST_NOEXCEPT { view_ =  null_char_(); }          // Boost extension
+
+    std::basic_string<value_type, traits_type> to_string() const {
+        return std::basic_string<CharT, Traits>(begin(), end());
+    }
+
+    template<typename Allocator>
+    std::basic_string<value_type, traits_type, Allocator> to_string(const Allocator& a) const {
+        return std::basic_string<value_type, traits_type, Allocator>(begin(), end(), a);
+    }
+
+  private:
+    BOOST_CONSTEXPR static const_pointer   null_char_()         {return detail::null_char_(CharT{});}
+    const_pointer view_;
+};
+
+template<class charT, class traits>
+inline std::basic_ostream<charT, traits>&
+operator<<(std::basic_ostream<charT, traits>& os,
+           const basic_cstring_ref<charT,traits>& str)
+{
+    return os << static_cast<basic_string_view<charT, traits>>(str);
+}
+
+template <class charT, class traits>
+std::size_t hash_value(basic_string_view<charT, traits> s) {
+    return boost::hash_range(s.begin(), s.end());
+}
+
+using cstring_ref    = basic_cstring_ref<char>;
+using wcstring_ref   = basic_cstring_ref<wchar_t>;
+using u16cstring_ref = basic_cstring_ref<char16_t>;
+using u32cstring_ref = basic_cstring_ref<char32_t>;
+
+#if defined(BOOST_PROCESS_V2_HAS_CHAR8_T)
+using u8cstring_ref  = basic_cstring_ref<char8_t>;
+#endif
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_CSTRING_REF_HPP

include/boost/process/v2/default_launcher.hpp

@@ -0,0 +1,66 @@
+//
+// boost/process/v2/default_launcher.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2022 Klemens D. Morgenstern (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_PROCESS_V2_DEFAULT_LAUNCHER_HPP
+#define BOOST_PROCESS_V2_DEFAULT_LAUNCHER_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+
+#if defined(BOOST_PROCESS_V2_WINDOWS)
+#include <boost/process/v2/windows/default_launcher.hpp>
+#else
+#if defined(BOOST_PROCESS_V2_PDFORK)
+#include <boost/process/v2/posix/pdfork_launcher.hpp>
+#else
+#include <boost/process/v2/posix/default_launcher.hpp>
+#endif
+
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// The default launcher for processes.
+/** This launcher will be used by process if a 
+ * process is launched through the constructor:
+ * 
+ * @code {.cpp}
+ * process proc("test", {});
+ * // equivalent to
+ * process prod = default_launcher()("test", {});
+ * @endcode
+ * 
+ */
+
+typedef implementation_defined default_process_launcher;
+
+#else
+#if defined(BOOST_PROCESS_V2_WINDOWS)
+typedef windows::default_launcher default_process_launcher;
+#else
+#if defined(BOOST_PROCESS_V2_PDFORK)
+typedef posix::pdfork_launcher default_process_launcher;
+#else
+typedef posix::default_launcher default_process_launcher;
+#endif
+#endif
+
+
+#endif
+
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#if defined(BOOST_PROCESS_V2_HEADER_ONLY)
+#include <boost/process/v2/impl/default_launcher.ipp>
+#endif
+
+#endif //BOOST_PROCESS_V2_DEFAULT_LAUNCHER_HPP

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

@@ -0,0 +1,155 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_CONFIG_HPP
+#define BOOST_PROCESS_V2_DETAIL_CONFIG_HPP
+
+#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)
+
+
+#include <asio/detail/config.hpp>
+#include <system_error>
+#include <filesystem>
+#include <string_view>
+#include <iomanip>
+
+#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)
+#define BOOST_PROCESS_V2_POSIX 1
+#endif
+
+#define BOOST_PROCESS_V2_BEGIN_NAMESPACE namespace process_v2 {
+#define BOOST_PROCESS_V2_END_NAMESPACE   }
+#define BOOST_PROCESS_V2_NAMESPACE process_v2
+
+#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)
+
+
+#include <boost/config.hpp>
+#include <boost/io/quoted.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/system/system_error.hpp>
+
+#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
+
+#if defined(BOOST_POSIX_API)
+#define BOOST_PROCESS_V2_POSIX 1
+#endif
+
+#if !defined(BOOST_PROCESS_V2_WINDOWS) && !defined(BOOST_POSIX_API)
+#error Unsupported operating system
+#endif
+
+#if defined(BOOST_PROCESS_USE_STD_FS)
+#include <filesystem>
+#include <optional>
+#else
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/optional.hpp>
+#endif
+
+#define BOOST_PROCESS_V2_BEGIN_NAMESPACE namespace boost { namespace process { namespace v2 {
+#define BOOST_PROCESS_V2_END_NAMESPACE  } } }
+#define BOOST_PROCESS_V2_NAMESPACE boost::process::v2
+
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+#if defined(BOOST_PROCESS_STANDALONE)
+
+using std::error_code ;
+using std::error_category ;
+using std::system_category ;
+using std::system_error ;
+namespace filesystem = std::filesystem;
+using std::quoted;
+using std::optional;
+
+#else
+
+using boost::system::error_code ;
+using boost::system::error_category ;
+using boost::system::system_category ;
+using boost::system::system_error ;
+using boost::io::quoted;
+using boost::optional;
+
+#ifdef BOOST_PROCESS_USE_STD_FS
+namespace filesystem = std::filesystem;
+#else
+namespace filesystem = boost::filesystem;
+#endif
+
+#endif
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#ifndef BOOST_PROCESS_V2_HEADER_ONLY
+# ifndef BOOST_PROCESS_V2_SEPARATE_COMPILATION
+#   define BOOST_PROCESS_V2_HEADER_ONLY 1
+# endif
+#endif
+
+#if BOOST_PROCESS_V2_DOXYGEN
+# define BOOST_PROCESS_V2_DECL
+#elif defined(BOOST_PROCESS_V2_HEADER_ONLY)
+# define BOOST_PROCESS_V2_DECL inline
+#else
+# define BOOST_PROCESS_V2_DECL
+#endif
+
+#if defined(BOOST_PROCESS_V2_POSIX)
+
+#if defined(__linux__) && !defined(BOOST_PROCESS_V2_DISABLE_PIDFD_OPEN)
+
+#include <sys/syscall.h>
+
+#if defined(SYS_pidfd_open)
+#define BOOST_PROCESS_V2_PIDFD_OPEN 1
+#define BOOST_PROCESS_V2_HAS_PROCESS_HANDLE 1
+#endif
+#endif
+
+#if defined(__FreeBSD__) && !defined(BOOST_PROCESS_V2_DISABLE_PDFORK)
+#define BOOST_PROCESS_V2_PDFORK 1
+#define BOOST_PROCESS_V2_HAS_PROCESS_HANDLE 1
+#endif
+#else
+#define BOOST_PROCESS_V2_HAS_PROCESS_HANDLE 1
+#endif
+
+
+
+#endif //BOOST_PROCESS_V2_DETAIL_CONFIG_HPP

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

@@ -0,0 +1,80 @@
+//
+// process/environment/detail/environment_posix.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 Klemens D. Morgenstern (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_POSIX_HPP
+#define BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_POSIX_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/cstring_ref.hpp>
+
+#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__APPLE__) || defined(__MACH__)
+extern "C" { extern char **environ; }
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace environment
+{
+
+using char_type = char;
+
+template<typename Char>
+using key_char_traits = std::char_traits<Char>;
+
+template<typename Char>
+using value_char_traits = std::char_traits<Char>;
+
+
+constexpr char_type equality_sign = '=';
+constexpr char_type delimiter = ':';
+
+namespace detail
+{
+
+BOOST_PROCESS_V2_DECL
+basic_cstring_ref<char_type, value_char_traits<char>>
+get(basic_cstring_ref<char_type, key_char_traits<char_type>> key, error_code & ec);
+
+BOOST_PROCESS_V2_DECL
+void set(basic_cstring_ref<char_type, key_char_traits<char_type>> key,
+         basic_cstring_ref<char_type, value_char_traits<char_type>> value,
+         error_code & ec);
+
+BOOST_PROCESS_V2_DECL
+void unset(basic_cstring_ref<char_type, key_char_traits<char_type>> key,
+           error_code & ec);
+}
+
+
+using native_handle_type   = const char * const *;
+using native_iterator = native_handle_type;
+
+namespace detail
+{
+
+BOOST_PROCESS_V2_DECL native_handle_type load_native_handle();
+struct native_handle_deleter
+{
+    void operator()(native_handle_type) const {}
+};
+
+BOOST_PROCESS_V2_DECL native_iterator next(native_handle_type nh);
+BOOST_PROCESS_V2_DECL native_iterator find_end(native_handle_type nh);
+inline const char_type * dereference(native_iterator iterator) {return *iterator;}
+
+BOOST_PROCESS_V2_DECL bool is_executable(const filesystem::path & pth, error_code & ec);
+
+}
+
+}
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif

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

@@ -0,0 +1,212 @@
+//
+// process/environment/detail/environment_win.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 Klemens D. Morgenstern (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_WIN_HPP
+#define BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_WIN_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/cstring_ref.hpp>
+
+#include <cwctype>
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace environment
+{
+
+using char_type = wchar_t;
+
+template<typename Char>
+struct key_char_traits
+{
+  typedef Char      char_type;
+  typedef typename std::char_traits<char_type>::int_type  int_type;
+  typedef typename std::char_traits<char_type>::off_type   off_type;
+  typedef typename std::char_traits<char_type>::pos_type   pos_type;
+  typedef typename std::char_traits<char_type>::state_type state_type;
+
+  BOOST_CONSTEXPR static char    to_lower(char c)    {return std::tolower(to_int_type(c));}
+  BOOST_CONSTEXPR static wchar_t to_lower(wchar_t c) {return std::towlower(to_int_type(c));}
+
+  BOOST_CONSTEXPR static int_type to_lower(int_type i, char )   {return std::tolower(i);}
+  BOOST_CONSTEXPR static int_type to_lower(int_type i, wchar_t) {return std::towlower(i);}
+
+
+  BOOST_CONSTEXPR static
+  void assign(char_type& c1, const char_type& c2) BOOST_NOEXCEPT
+  {
+    c1 = c2;
+  }
+
+  BOOST_CONSTEXPR static
+  bool eq(char_type c1, char_type c2) BOOST_NOEXCEPT
+  {
+    return to_lower(c1) == to_lower(c2);
+  }
+
+  BOOST_CONSTEXPR static
+  bool lt(char_type c1, char_type c2) BOOST_NOEXCEPT
+  {
+    return to_lower(c1) < to_lower(c2);
+  }
+
+  BOOST_CONSTEXPR static
+  int compare(const char_type* s1, const char_type* s2, size_t n) BOOST_NOEXCEPT
+  {
+    auto itrs = std::mismatch(s1, s1 + n, s2, &eq);
+    if (itrs.first == (s1 + n))
+      return 0;
+    auto c1 = to_lower(*itrs.first);
+    auto c2 = to_lower(*itrs.second);
+
+    return (c1 < c2 ) ? -1 : 1;
+  }
+
+  BOOST_CONSTEXPR static size_t length(const char* s)    BOOST_NOEXCEPT  { return std::strlen(s); }
+  BOOST_CONSTEXPR static size_t length(const wchar_t* s) BOOST_NOEXCEPT  { return std::wcslen(s); }
+
+  BOOST_CONSTEXPR static
+  const char_type* find(const char_type* s, size_t n, const char_type& a) BOOST_NOEXCEPT
+  {
+    const char_type u = to_lower(a);
+    return std::find_if(s, s + n, [u](char_type c){return to_lower(c) == u;});
+  }
+
+  BOOST_CONSTEXPR static
+  char_type* move(char_type* s1, const char_type* s2, size_t n) BOOST_NOEXCEPT
+  {
+    if (s1 < s2)
+      return std::move(s2, s2 + n, s1);
+    else
+      return std::move_backward(s2, s2 + n, s1);
+  }
+
+  BOOST_CONSTEXPR static
+  char_type* copy(char_type* s1, const char_type* s2, size_t n) BOOST_NOEXCEPT
+  {
+    return std::copy(s2, s2 + n, s1);
+  }
+
+  BOOST_CONSTEXPR static
+  char_type* assign(char_type* s, size_t n, char_type a) BOOST_NOEXCEPT
+  {
+    std::fill(s, s + n, a);
+    return s +n;
+  }
+
+  BOOST_CONSTEXPR static
+  int_type not_eof(int_type c) BOOST_NOEXCEPT
+  {
+    return eq_int_type(c, eof()) ? ~eof() : c;
+  }
+
+  BOOST_CONSTEXPR static
+  char_type to_char_type(int_type c) BOOST_NOEXCEPT
+  {
+    return char_type(c);
+  }
+
+  BOOST_CONSTEXPR static
+  int_type to_int_type(char c) BOOST_NOEXCEPT
+  {
+    return int_type((unsigned char)c);
+  }
+
+  BOOST_CONSTEXPR static
+  int_type to_int_type(wchar_t c) BOOST_NOEXCEPT
+  {
+    return int_type((wchar_t)c);
+  }
+
+  BOOST_CONSTEXPR static
+  bool eq_int_type(int_type c1, int_type c2) BOOST_NOEXCEPT
+  {
+    return to_lower(c1, char_type()) == to_lower(c2, char_type());
+  }
+
+  BOOST_CONSTEXPR static inline int_type eof() BOOST_NOEXCEPT
+  {
+    return int_type(EOF);
+  }
+};
+
+namespace detail
+{
+
+
+template<typename Char>
+std::size_t hash_step(std::size_t prev, Char c, key_char_traits<Char>)
+{
+    return prev ^ (key_char_traits<Char>::to_lower(c) << 1);
+}
+
+
+}
+
+template<typename Char>
+using value_char_traits = std::char_traits<Char>;
+
+BOOST_CONSTEXPR static char_type equality_sign = L'=';
+BOOST_CONSTEXPR static char_type delimiter = L';';
+
+using native_handle_type   = wchar_t*;
+using native_iterator = const wchar_t*;
+
+namespace detail
+{
+
+BOOST_PROCESS_V2_DECL
+std::basic_string<wchar_t, value_char_traits<wchar_t>> get(
+        basic_cstring_ref<wchar_t, key_char_traits<wchar_t>> key,
+        error_code & ec);
+
+BOOST_PROCESS_V2_DECL
+void set(basic_cstring_ref<wchar_t,   key_char_traits<wchar_t>> key,
+         basic_cstring_ref<wchar_t, value_char_traits<wchar_t>> value,
+         error_code & ec);
+
+BOOST_PROCESS_V2_DECL
+void unset(basic_cstring_ref<wchar_t, key_char_traits<wchar_t>> key,
+           error_code & ec);
+
+
+BOOST_PROCESS_V2_DECL
+std::basic_string<char, value_char_traits<char>> get(
+        basic_cstring_ref<char, key_char_traits<char>> key,
+        error_code & ec);
+
+BOOST_PROCESS_V2_DECL
+void set(basic_cstring_ref<char,   key_char_traits<char>> key,
+         basic_cstring_ref<char, value_char_traits<char>> value,
+         error_code & ec);
+
+BOOST_PROCESS_V2_DECL
+void unset(basic_cstring_ref<char, key_char_traits<char>> key,
+           error_code & ec);
+
+BOOST_PROCESS_V2_DECL native_handle_type load_native_handle();
+struct native_handle_deleter
+{
+  native_handle_deleter() = default;
+  native_handle_deleter(const native_handle_deleter& ) = default;
+  BOOST_PROCESS_V2_DECL void operator()(native_handle_type nh) const;
+
+};
+
+inline const char_type * dereference(native_iterator iterator) {return iterator;}
+BOOST_PROCESS_V2_DECL native_iterator next(native_iterator nh);
+BOOST_PROCESS_V2_DECL native_iterator find_end(native_handle_type nh);
+BOOST_PROCESS_V2_DECL bool is_executable(const filesystem::path & pth, error_code & ec);
+}
+
+}
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_WIN_HPP

include/boost/process/v2/detail/impl/environment.ipp

@@ -0,0 +1,18 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_IMPL_ENVIRONMENT_IPP
+#define BOOST_PROCESS_V2_DETAIL_IMPL_ENVIRONMENT_IPP
+
+#include <boost/process/v2/detail/config.hpp>
+
+#if defined(BOOST_PROCESS_V2_WINDOWS)
+#include <boost/process/v2/detail/impl/environment_win.ipp>
+#elif defined(BOOST_PROCESS_V2_POSIX)
+#include <boost/process/v2/detail/impl/environment_posix.ipp>
+#else
+#error Operating System not supported.
+#endif
+
+#endif //BOOST_PROCESS_V2_DETAIL_IMPL_ENVIRONMENT_IPP

include/boost/process/v2/detail/impl/environment_posix.ipp

@@ -0,0 +1,81 @@
+//
+// process/this_process/detail/environment_posix.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 Klemens D. Morgenstern (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_WIN_HPP
+#define BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_WIN_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/detail/last_error.hpp>
+#include <boost/process/v2/environment.hpp>
+#include <boost/process/v2/cstring_ref.hpp>
+
+#include <unistd.h>
+#include <cstring>
+
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace environment
+{
+namespace detail
+{
+
+basic_cstring_ref<char_type, value_char_traits<char>> get(
+        basic_cstring_ref<char_type, key_char_traits<char_type>> key,
+        error_code & ec)
+{
+    auto res = ::getenv(key.c_str());
+    if (res == nullptr)
+    {
+        ec.assign(ENOENT, system_category());
+        return {};
+    }
+    return res;
+}
+
+void set(basic_cstring_ref<char_type,   key_char_traits<char_type>>   key,
+         basic_cstring_ref<char_type, value_char_traits<char_type>> value,
+                error_code & ec)
+{
+    if (::setenv(key.c_str(), value.c_str(), true))
+        ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+}
+
+void unset(basic_cstring_ref<char_type, key_char_traits<char_type>> key, error_code & ec)
+{
+    if (::unsetenv(key.c_str()))
+        ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+}
+
+
+native_handle_type load_native_handle() { return ::environ; }
+
+
+native_iterator next(native_iterator nh)
+{
+    return nh + 1;
+}
+
+native_iterator find_end(native_handle_type nh)
+{
+    while (*nh != nullptr)
+        nh++;
+    return nh;
+}
+bool is_executable(const filesystem::path & p, error_code & ec)
+{
+    return filesystem::is_regular_file(p, ec) && (::access(p.c_str(), X_OK) == 0);
+}
+
+}
+}
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_DETAIL_ENVIRONMENT_WIN_HPP

include/boost/process/v2/detail/impl/environment_win.ipp

@@ -0,0 +1,142 @@
+//
+// process/this_process/detail/environment_win.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2021 Klemens D. Morgenstern (klemens dot morgenstern at gmx dot net)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef BOOST_PROCESS_V2_DETAIL_IMPL_ENVIRONMENT_WIN_IPP
+#define BOOST_PROCESS_V2_DETAIL_IMPL_ENVIRONMENT_WIN_IPP
+
+
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/detail/environment_win.hpp>
+#include <boost/process/v2/detail/impl/environment.ipp>
+#include <boost/process/v2/detail/last_error.hpp>
+
+#include <algorithm>
+#include <cwctype>
+#include <cstring>
+
+#include <shellapi.h>
+
+#include <boost/process/v2/cstring_ref.hpp>
+#include <boost/process/v2/error.hpp>
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace environment
+{
+namespace detail
+{
+
+std::basic_string<char_type, value_char_traits<char_type>> get(
+        basic_cstring_ref<char_type, key_char_traits<char_type>> key,
+        error_code & ec)
+{
+  std::basic_string<char_type, value_char_traits<char_type>> buf;
+
+  std::size_t size = 0u;
+  do
+  {
+    buf.resize(buf.size() + 4096);
+    size = ::GetEnvironmentVariableW(key.c_str(), &buf.front(), static_cast<DWORD>(buf.size()));
+  }
+  while (size == buf.size());
+
+  buf.resize(size);
+
+  if (buf.size() == 0)
+    ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+
+  return buf;
+}
+
+void set(basic_cstring_ref<char_type,   key_char_traits<char_type>>   key,
+         basic_cstring_ref<char_type, value_char_traits<char_type>> value,
+         error_code & ec)
+{
+  if (!::SetEnvironmentVariableW(key.c_str(), value.c_str()))
+    ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+}
+
+void unset(basic_cstring_ref<char_type, key_char_traits<char_type>> key,
+           error_code & ec)
+{
+  if (!::SetEnvironmentVariableW(key.c_str(), nullptr))
+    ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+}
+
+
+std::basic_string<char, value_char_traits<char>> get(
+        basic_cstring_ref<char, key_char_traits<char>> key,
+        error_code & ec)
+{
+  std::basic_string<char, value_char_traits<char>> buf;
+
+  std::size_t size = 0u;
+  do
+  {
+    buf.resize(buf.size() + 4096);
+    size = ::GetEnvironmentVariableA(key.c_str(), &buf.front(), static_cast<DWORD>(buf.size()));
+  }
+  while (size == buf.size());
+
+  buf.resize(size);
+
+  if (buf.size() == 0)
+    ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+
+  return buf;
+}
+
+void set(basic_cstring_ref<char,   key_char_traits<char>>   key,
+         basic_cstring_ref<char, value_char_traits<char>> value,
+         error_code & ec)
+{
+  if (!::SetEnvironmentVariableA(key.c_str(), value.c_str()))
+    ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+}
+
+void unset(basic_cstring_ref<char, key_char_traits<char>> key,
+           error_code & ec)
+{
+  if (!::SetEnvironmentVariableA(key.c_str(), nullptr))
+    ec = ::BOOST_PROCESS_V2_NAMESPACE::detail::get_last_error();
+}
+
+
+native_handle_type load_native_handle() { return ::GetEnvironmentStringsW(); }
+void native_handle_deleter::operator()(native_handle_type nh) const
+{
+    ::FreeEnvironmentStringsW(nh);
+}
+
+native_iterator next(native_iterator nh)
+{
+    while (*nh != L'\0')
+        nh++;
+    return ++nh;
+}
+
+
+native_iterator find_end(native_handle_type nh)
+{
+  while ((*nh != L'\0') || (*std::next(nh) != L'\0'))
+    nh++;
+  return ++nh;
+}
+
+bool is_executable(const filesystem::path & pth, error_code & ec)
+{
+    return filesystem::is_regular_file(pth, ec) && SHGetFileInfoW(pth.native().c_str(), 0,0,0, SHGFI_EXETYPE);
+}
+
+}
+}
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_DETAIL_IMPL_ENVIRONMENT_WIN_IPP

include/boost/process/v2/detail/impl/last_error.ipp

@@ -0,0 +1,48 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_IMPL_LAST_ERROR_IPP
+#define BOOST_PROCESS_V2_DETAIL_IMPL_LAST_ERROR_IPP
+
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/detail/last_error.hpp>
+
+#if defined(BOOST_PROCESS_V2_WINDOWS)
+#include <windows.h>
+#else
+#include <cerrno>
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+namespace detail
+{
+
+error_code get_last_error()
+{
+#if defined(BOOST_PROCESS_V2_WINDOWS)
+    return error_code(::GetLastError(), system_category());
+#else
+    return error_code(errno, system_category());
+#endif
+
+}
+
+void throw_last_error()
+{
+    throw system_error(get_last_error());
+}
+void throw_last_error(const char * msg)
+{
+    throw system_error(get_last_error(), msg);
+}
+void throw_last_error(const std::string & msg)
+{
+    throw system_error(get_last_error(), msg);
+}
+
+
+}
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_DETAIL_IMPL_LAST_ERROR_IPP

include/boost/process/v2/detail/impl/process_handle_windows.ipp

@@ -0,0 +1,126 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_IMPL_PROCESS_HANDLE_WINDOWS_IPP
+#define BOOST_PROCESS_V2_DETAIL_IMPL_PROCESS_HANDLE_WINDOWS_IPP
+
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/detail/last_error.hpp>
+#include <boost/process/v2/detail/throw_error.hpp>
+#include <boost/process/v2/detail/process_handle_windows.hpp>
+
+#include <windows.h>
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace detail
+{
+
+void get_exit_code_(
+    HANDLE handle,
+    native_exit_code_type & exit_code, 
+    error_code & ec)
+{
+    if (!::GetExitCodeProcess(handle, &exit_code))
+        ec = detail::get_last_error();
+}
+
+
+HANDLE open_process_(DWORD pid)
+{
+    auto proc = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE, FALSE, pid);
+    if (proc == nullptr)
+        detail::throw_last_error("open_process()");
+    return proc;
+}
+
+
+void terminate_if_running_(HANDLE handle)
+{
+    DWORD exit_code = 0u;
+    if (handle == INVALID_HANDLE_VALUE)
+      return ;
+    if (::GetExitCodeProcess(handle, &exit_code))
+      if (exit_code == STILL_ACTIVE)
+        ::TerminateProcess(handle, 260);
+}
+
+bool check_handle_(HANDLE handle, error_code & ec)
+{
+    if (handle == INVALID_HANDLE_VALUE)
+    {
+        ec.assign(ERROR_INVALID_HANDLE_STATE, system_category());
+        return false;
+    }
+    return true;
+}
+
+bool check_pid_(pid_type pid_, error_code & ec)
+{
+    if (pid_ == 0)
+    {
+      ec.assign(ERROR_INVALID_HANDLE_STATE, system_category());
+      return false;
+    }
+    return true;
+}
+
+struct enum_windows_data_t
+{
+    error_code &ec;
+    pid_type pid;
+};
+
+static BOOL CALLBACK enum_window(HWND hwnd, LPARAM param)
+  {
+    auto data = reinterpret_cast<enum_windows_data_t*>(param);
+    DWORD pid{0u};
+    GetWindowThreadProcessId(hwnd, &pid);
+
+    if (pid != data->pid)
+      return TRUE;
+
+    LRESULT res = ::SendMessageW(hwnd, WM_CLOSE, 0, 0);
+    if (!res)
+      data->ec = detail::get_last_error();
+    return res != 0;
+  }
+
+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)))
+        ec = detail::get_last_error();
+}
+
+void interrupt_(pid_type pid_, error_code & ec)
+{
+    if (!::GenerateConsoleCtrlEvent(CTRL_C_EVENT, pid_))
+        ec = detail::get_last_error();
+}
+
+void terminate_(HANDLE handle, error_code & ec, DWORD & exit_status)
+{
+    if (!::TerminateProcess(handle, 260))
+        ec = detail::get_last_error();
+}
+
+void check_running_(HANDLE handle, error_code & ec, DWORD & exit_status)
+{
+    if (!::GetExitCodeProcess(handle, &exit_status))
+        ec = detail::get_last_error();
+}
+
+
+#if !defined(BOOST_PROCESS_V2_HEADER_ONLY)
+template struct basic_process_handle_win<>;
+#endif
+
+}
+
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_DETAIL_IMPL_PROCESS_HANDLE_WINDOWS_IPP

include/boost/process/v2/detail/impl/throw_error.ipp

@@ -0,0 +1,31 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_IMPL_THROW_ERROR_IPP
+#define BOOST_PROCESS_V2_DETAIL_IMPL_THROW_ERROR_IPP
+
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/detail/throw_error.hpp>
+#include <boost/process/v2/detail/throw_exception.hpp>
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+namespace detail
+{
+
+void do_throw_error(const error_code& err)
+{
+    system_error e(err);
+    throw_exception(e);
+}
+
+void do_throw_error(const error_code& err, const char* location)
+{
+    system_error e(err, location);
+    throw_exception(e);
+}
+
+}
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_DETAIL_IMPL_THROW_ERROR_IPP

include/boost/process/v2/detail/impl/utf8.ipp

@@ -0,0 +1,379 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_IMPL_UTF8_HPP
+#define BOOST_PROCESS_V2_DETAIL_IMPL_UTF8_HPP
+
+#include <boost/process/v2/detail/utf8.hpp>
+#include <boost/process/v2/detail/config.hpp>
+#include <boost/process/v2/detail/last_error.hpp>
+#include <boost/process/v2/error.hpp>
+
+#if defined(BOOST_PROCESS_V2_WINDOWS)
+#include <Windows.h>
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace detail
+{
+
+#if defined(BOOST_PROCESS_V2_WINDOWS)
+
+inline void handle_error(error_code & ec)
+{
+    const auto err = ::GetLastError();
+    switch (err)
+    {
+    case ERROR_INSUFFICIENT_BUFFER:
+        ec.assign(error::insufficient_buffer, error::utf8_category);
+        break;
+    case ERROR_NO_UNICODE_TRANSLATION:
+        ec.assign(error::invalid_character, error::utf8_category);
+        break;
+    default:
+        ec.assign(err, system_category());
+    }
+}
+
+std::size_t size_as_utf8(const wchar_t * in, std::size_t size, error_code & ec)
+{
+    auto res = WideCharToMultiByte(
+                          CP_UTF8,                // CodePage,
+                          0,                      // dwFlags,
+                          in,                     // lpWideCharStr,
+                          static_cast<int>(size), // cchWideChar,
+                          nullptr,                // lpMultiByteStr,
+                          0,                      // cbMultiByte,
+                          nullptr,                // lpDefaultChar,
+                          FALSE);                 // lpUsedDefaultChar
+    
+    if (res == 0u)
+        handle_error(ec);
+    return static_cast<std::size_t>(res);
+}
+
+std::size_t size_as_wide(const char * in, std::size_t size, error_code & ec)
+{
+    auto res = ::MultiByteToWideChar(
+                          CP_UTF8,                // CodePage
+                          0,                      // dwFlags
+                          in,                     // lpMultiByteStr
+                          static_cast<int>(size), // cbMultiByte
+                          nullptr,                // lpWideCharStr
+                          0);                     // cchWideChar
+    if (res == 0u)
+        handle_error(ec);
+
+    return static_cast<std::size_t>(res);
+}
+
+std::size_t convert_to_utf8(const wchar_t *in, std::size_t size,  char * out, 
+                            std::size_t max_size, error_code & ec)
+{
+    auto res = ::WideCharToMultiByte(
+                    CP_UTF8,                    // CodePage
+                    0,                          // dwFlags
+                    in,                         // lpWideCharStr
+                    static_cast<int>(size),     // cchWideChar
+                    out,                        // lpMultiByteStr
+                    static_cast<int>(max_size), // cbMultiByte
+                    nullptr,                    // lpDefaultChar
+                    FALSE);                     // lpUsedDefaultChar
+    if (res == 0u)
+        handle_error(ec);
+
+    return static_cast<std::size_t>(res);
+}
+
+std::size_t convert_to_wide(const char *in, std::size_t size,  wchar_t * out, 
+                            std::size_t max_size, error_code & ec)
+{
+    auto res = ::MultiByteToWideChar(
+                          CP_UTF8,                     // CodePage
+                          0,                           // dwFlags
+                          in,                          // lpMultiByteStr
+                          static_cast<int>(size),      // cbMultiByte
+                          out,                         // lpWideCharStr
+                          static_cast<int>(max_size)); // cchWideChar
+    if (res == 0u)
+        handle_error(ec);
+
+    return static_cast<std::size_t>(res);
+}
+
+#else
+
+
+template<std::size_t s>
+inline int get_cont_octet_out_count_impl(wchar_t word) {
+    if (word < 0x80) {
+        return 0;
+    }
+    if (word < 0x800) {
+        return 1;
+    }
+    return 2;
+}
+
+template<>
+inline int get_cont_octet_out_count_impl<4>(wchar_t word) {
+    if (word < 0x80) {
+        return 0;
+    }
+    if (word < 0x800) {
+        return 1;
+    }
+
+    // Note that the following code will generate warnings on some platforms
+    // where wchar_t is defined as UCS2.  The warnings are superfluous as the
+    // specialization is never instantitiated with such compilers, but this
+    // can cause problems if warnings are being treated as errors, so we guard
+    // against that. Including <boost/detail/utf8_codecvt_facet.hpp> as we do
+    // should be enough to get WCHAR_MAX defined.
+#if !defined(WCHAR_MAX)
+#   error WCHAR_MAX not defined!
+#endif
+    // cope with VC++ 7.1 or earlier having invalid WCHAR_MAX
+#if defined(_MSC_VER) && _MSC_VER <= 1310 // 7.1 or earlier
+    return 2;
+#elif WCHAR_MAX > 0x10000
+
+    if (word < 0x10000) {
+        return 2;
+    }
+    if (word < 0x200000) {
+        return 3;
+    }
+    if (word < 0x4000000) {
+        return 4;
+    }
+    return 5;
+
+#else
+    return 2;
+#endif
+}
+
+inline int get_cont_octet_out_count(wchar_t word)
+{
+    return detail::get_cont_octet_out_count_impl<sizeof(wchar_t)>(word);
+}
+
+// copied from boost/detail/utf8_codecvt_facet.ipp
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
+
+inline unsigned int get_octet_count(unsigned char lead_octet)
+{
+    // if the 0-bit (MSB) is 0, then 1 character
+    if (lead_octet <= 0x7f) return 1;
+
+    // Otherwise the count number of consecutive 1 bits starting at MSB
+//    assert(0xc0 <= lead_octet && lead_octet <= 0xfd);
+
+    if (0xc0 <= lead_octet && lead_octet <= 0xdf) return 2;
+    else if (0xe0 <= lead_octet && lead_octet <= 0xef) return 3;
+    else if (0xf0 <= lead_octet && lead_octet <= 0xf7) return 4;
+    else if (0xf8 <= lead_octet && lead_octet <= 0xfb) return 5;
+    else return 6;
+}
+
+inline bool invalid_continuing_octet(unsigned char octet_1) {
+    return (octet_1 < 0x80|| 0xbf< octet_1);
+}
+
+inline unsigned int get_cont_octet_count(unsigned char lead_octet)
+{
+    return get_octet_count(lead_octet) - 1;
+}
+
+inline const wchar_t * get_octet1_modifier_table() noexcept
+{
+    static const wchar_t octet1_modifier_table[] = {
+        0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
+    };
+    return octet1_modifier_table;
+}
+
+
+std::size_t size_as_utf8(const wchar_t * in, std::size_t size, error_code & ec)
+{
+    std::size_t res = 0u;
+    const auto from_end = in + size;
+    for (auto from = in; from != from_end; from++)
+        res += get_cont_octet_out_count(*from) + 1;
+    return res;
+}
+
+std::size_t size_as_wide(const  char   * in, std::size_t size, error_code & ec)
+{
+    const auto from = in;
+    const auto from_end = from + size;
+    const char * from_next = from;
+    for (std::size_t char_count = 0u; from_next < from_end; ++char_count) {
+        unsigned int octet_count = get_octet_count(*from_next);
+        // The buffer may represent incomplete characters, so terminate early if one is found
+        if (octet_count > static_cast<std::size_t>(from_end - from_next))
+            break;
+        from_next += octet_count;
+    }
+
+    return from_next - from;
+}
+
+std::size_t convert_to_utf8(const wchar_t * in, std::size_t size,
+                            char   * out, std::size_t max_size, error_code & ec)
+{
+
+    const wchar_t * from = in;
+    const wchar_t * from_end = from + size;
+    const wchar_t * & from_next = from;
+    char * to = out;
+    char * to_end = out + max_size;
+    char * & to_next = to;
+
+    const wchar_t * const octet1_modifier_table = get_octet1_modifier_table();
+    wchar_t max_wchar = (std::numeric_limits<wchar_t>::max)();
+    while (from != from_end && to != to_end) {
+
+        // Check for invalid UCS-4 character
+        if (*from  > max_wchar) {
+            from_next = from;
+            to_next = to;
+            ec.assign(error::invalid_character, error::get_utf8_category());
+            return 0u;
+        }
+
+        int cont_octet_count = get_cont_octet_out_count(*from);
+
+        // RG - comment this formula better
+        int shift_exponent = cont_octet_count * 6;
+
+        // Process the first character
+        *to++ = static_cast<char>(octet1_modifier_table[cont_octet_count] +
+                                  (unsigned char)(*from / (1 << shift_exponent)));
+
+        // Process the continuation characters
+        // Invariants: At the start of the loop:
+        //   1) 'i' continuing octets have been generated
+        //   2) '*to' points to the next location to place an octet
+        //   3) shift_exponent is 6 more than needed for the next octet
+        int i = 0;
+        while (i != cont_octet_count && to != to_end) {
+            shift_exponent -= 6;
+            *to++ = static_cast<char>(0x80 + ((*from / (1 << shift_exponent)) % (1 << 6)));
+            ++i;
+        }
+        // If we filled up the out buffer before encoding the character
+        if (to == to_end && i != cont_octet_count) {
+            from_next = from;
+            to_next = to - (i + 1);
+            ec.assign(error::insufficient_buffer, error::get_utf8_category());
+            return 0u;
+        }
+        ++from;
+    }
+    from_next = from;
+    to_next = to;
+
+    // Were we done or did we run out of destination space
+    if (from != from_end)
+        ec.assign(error::insufficient_buffer, error::get_utf8_category());
+
+    return to_next - out;
+}
+
+inline bool invalid_leading_octet(unsigned char octet_1) {
+    return (0x7f < octet_1 && octet_1 < 0xc0) ||
+           (octet_1 > 0xfd);
+}
+
+std::size_t convert_to_wide(const  char   * in, std::size_t size,
+                            wchar_t * out, std::size_t max_size, error_code & ec)
+{
+    const char * from = in;
+    const char * from_end = from + size;
+    const char * & from_next = from;
+    wchar_t * to = out;
+    wchar_t * to_end = out + max_size;
+    wchar_t * & to_next = to;
+
+    // Basic algorithm: The first octet determines how many
+    // octets total make up the UCS-4 character. The remaining
+    // "continuing octets" all begin with "10". To convert, subtract
+    // the amount that specifies the number of octets from the first
+    // octet. Subtract 0x80 (1000 0000) from each continuing octet,
+    // then mash the whole lot together. Note that each continuing
+    // octet only uses 6 bits as unique values, so only shift by
+    // multiples of 6 to combine.
+    const wchar_t * const octet1_modifier_table = detail::get_octet1_modifier_table();
+    while (from != from_end && to != to_end) {
+
+        // Error checking on the first octet
+        if (invalid_leading_octet(*from)) {
+            from_next = from;
+            to_next = to;
+            ec.assign(error::invalid_character, error::get_utf8_category());
+            return 0u;
+        }
+
+        // The first octet is adjusted by a value dependent upon
+        // the number of "continuing octets" encoding the character
+        const int cont_octet_count = get_cont_octet_count(*from);
+
+        // The unsigned char conversion is necessary in case char is
+        // signed (I learned this the hard way)
+        wchar_t ucs_result =
+                (unsigned char)(*from++) - octet1_modifier_table[cont_octet_count];
+
+        // Invariants:
+        //   1) At the start of the loop, 'i' continuing characters have been
+        //      processed
+        //   2) *from points to the next continuing character to be processed.
+        int i = 0;
+        while (i != cont_octet_count && from != from_end) {
+
+            // Error checking on continuing characters
+            if (invalid_continuing_octet(*from)) {
+                from_next = from;
+                to_next = to;
+                ec.assign(error::invalid_character, error::get_utf8_category());
+                return 0u;
+            }
+
+            ucs_result *= (1 << 6);
+
+            // each continuing character has an extra (10xxxxxx)b attached to
+            // it that must be removed.
+            ucs_result += (unsigned char)(*from++) - 0x80;
+            ++i;
+        }
+
+        // If the buffer ends with an incomplete unicode character...
+        if (from == from_end && i != cont_octet_count) {
+            // rewind "from" to before the current character translation
+            from_next = from - (i + 1);
+            to_next = to;
+            ec.assign(error::insufficient_buffer, error::get_utf8_category());
+            return 0u;
+        }
+        *to++ = ucs_result;
+    }
+    from_next = from;
+    to_next = to;
+
+    if (from != from_end)
+        ec.assign(error::insufficient_buffer, error::get_utf8_category());
+
+    return to_next - out;
+}
+
+#endif
+
+}
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_V2_DETAIL_IMPL_UTF8_HPP

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

@@ -0,0 +1,29 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_LAST_ERROR_HPP
+#define BOOST_PROCESS_V2_DETAIL_LAST_ERROR_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace detail {
+
+BOOST_PROCESS_V2_DECL error_code get_last_error();
+BOOST_PROCESS_V2_DECL void throw_last_error();
+BOOST_PROCESS_V2_DECL void throw_last_error(const char * msg);
+BOOST_PROCESS_V2_DECL void throw_last_error(const std::string & msg);
+
+}
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#if defined(BOOST_PROCESS_V2_HEADER_ONLY)
+
+#include <boost/process/v2/detail/impl/last_error.ipp>
+
+#endif
+
+
+#endif //BOOST_PROCESS_V2_DETAIL_LAST_ERROR_HPP

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

@@ -0,0 +1,318 @@
+
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_PROCESS_HANDLE_FD_HPP
+#define BOOST_PROCESS_V2_DETAIL_PROCESS_HANDLE_FD_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/syscall.h>
+
+#include <boost/process/v2/detail/last_error.hpp>
+#include <boost/process/v2/detail/throw_error.hpp>
+#include <boost/process/v2/exit_code.hpp>
+#include <boost/process/v2/pid.hpp>
+
+#if defined(BOOST_PROCESS_V2_STANDALONE)
+#include <asio/any_io_executor.hpp>
+#include <asio/compose.hpp>
+#include <asio/posix/basic_stream_descriptor.hpp>
+#include <asio/post.hpp>
+#else
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/posix/basic_stream_descriptor.hpp>
+#include <boost/asio/post.hpp>
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace detail
+{
+
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+struct basic_process_handle_fd
+{
+    using native_handle_type = int;
+    
+    typedef Executor executor_type;
+
+    executor_type get_executor()
+    { return descriptor_.get_executor(); }
+
+    /// Rebinds the process_handle to another executor.
+    template<typename Executor1>
+    struct rebind_executor
+    {
+        /// The socket type when rebound to the specified executor.
+        typedef basic_process_handle_fd<Executor1> other;
+    };
+
+    template<typename ExecutionContext>
+    basic_process_handle_fd(ExecutionContext &context,
+                            typename std::enable_if<
+                                std::is_convertible<ExecutionContext &,
+                                    BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value>::type * = nullptr)
+            : pid_(-1), descriptor_(context)
+    {
+    }
+
+    basic_process_handle_fd(executor_type executor)
+            : pid_(-1), descriptor_(executor)
+    {
+    }
+
+    basic_process_handle_fd(executor_type executor, pid_type pid)
+            : pid_(pid), descriptor_(executor, syscall(SYS_pidfd_open, pid, 0))
+    {
+    }
+
+    basic_process_handle_fd(executor_type executor, pid_type pid, native_handle_type process_handle)
+            : pid_(pid), descriptor_(executor, process_handle)
+    {
+    }
+
+    basic_process_handle_fd(basic_process_handle_fd &&handle)
+            : pid_(handle.pid_), descriptor_(std::move(handle.descriptor_))
+    {
+        handle.pid_ = -1;
+    }
+
+    template<typename Executor1>
+    basic_process_handle_fd(basic_process_handle_fd<Executor1> &&handle)
+            : pid_(handle.pid_), descriptor_(std::move(handle.descriptor_))
+    {
+        handle.pid_ = -1;
+    }
+
+
+    basic_process_handle_fd& operator=(basic_process_handle_fd &&handle)
+    {
+        pid_ = handle.pid_;
+        descriptor_ = std::move(handle.descriptor_);
+        handle.pid_ = -1;
+        return *this;
+    }
+
+    pid_type id() const
+    { return pid_; }
+
+    void terminate_if_running(error_code &)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::waitpid(pid_, nullptr, WNOHANG) == 0)
+        {
+            ::kill(pid_, SIGKILL);
+            ::waitpid(pid_, nullptr, 0);
+        }
+    }
+
+    void terminate_if_running()
+    {
+        if (pid_ <= 0)
+            return;
+        if (::waitpid(pid_, nullptr, WNOHANG) == 0)
+        {
+            ::kill(pid_, SIGKILL);
+            ::waitpid(pid_, nullptr, 0);
+        }
+    }
+
+    void wait(native_exit_code_type &exit_status, error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        while (::waitpid(pid_, &exit_status, 0) < 0)
+        {
+            if (errno != EINTR)
+            {
+                ec = get_last_error();
+                break;
+            }   
+        }
+    }
+
+    void wait(native_exit_code_type &exit_status)
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        wait(exit_status, ec);
+        if (ec)
+            detail::throw_error(ec, "wait(pid)");
+    }
+
+    void interrupt(error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::kill(pid_, SIGINT) == -1)
+            ec = get_last_error();
+    }
+
+    void interrupt()
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        interrupt(ec);
+        if (ec)
+            detail::throw_error(ec, "interrupt");
+    }
+
+    void request_exit(error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::kill(pid_, SIGTERM) == -1)
+            ec = get_last_error();
+    }
+
+    void request_exit()
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        request_exit(ec);
+        if (ec)
+            detail::throw_error(ec, "request_exit");
+    }
+
+    void terminate(native_exit_code_type &exit_status, error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::kill(pid_, SIGKILL) == -1)
+            ec = get_last_error();
+    }
+
+    void terminate(native_exit_code_type &exit_status)
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        terminate(exit_status, ec);
+        if (ec)
+            detail::throw_error(ec, "terminate");
+    }
+
+    bool running(native_exit_code_type &exit_code, error_code & ec)
+    {
+        if (pid_ <= 0)
+            return false;
+        int code = 0;
+        int res = ::waitpid(pid_, &code, WNOHANG);
+        if (res == -1)
+            ec = get_last_error();
+        else if (res == 0)
+            return true;
+        else
+            ec.clear();
+
+        if (res == 0)
+            return true;
+        else
+        {
+            exit_code = code;
+            return false;
+        }
+    }
+
+    bool running(native_exit_code_type &exit_code)
+    {
+        if (pid_ <= 0)
+            return false;
+
+        error_code ec;
+        bool res = running(exit_code, ec);
+        if (ec)
+            detail::throw_error(ec, "is_running");
+        return res;
+    }
+
+    bool is_open() const
+    {
+        return pid_ != -1;
+    }
+
+    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, native_exit_code_type))
+    WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
+    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    {
+        return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                async_wait_op_{descriptor_, pid_}, handler, descriptor_);
+    }
+
+  private:
+    template<typename>
+    friend
+    struct basic_process_handle_fd;
+    pid_type pid_ = -1;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_stream_descriptor<Executor> descriptor_;
+
+    struct async_wait_op_
+    {
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_descriptor<Executor> &descriptor;
+        pid_type pid_;
+
+        template<typename Self>
+        void operator()(Self &&self)
+        {
+            error_code ec;
+            native_exit_code_type exit_code{};
+            int wait_res = -1;
+            if (pid_ <= 0) // error, complete early
+                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
+            else 
+            {
+                wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
+                if (wait_res == -1)
+                    ec = get_last_error();
+            }
+            
+
+            if (!ec && (wait_res == 0))
+            {
+                descriptor.async_wait(
+                        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::descriptor_base::wait_read, std::move(self));
+                return;
+            }
+
+            struct completer
+            {
+                error_code ec;
+                native_exit_code_type code;
+                typename std::decay<Self>::type self;
+
+                void operator()()
+                {
+                    self.complete(ec, code);
+                }
+            };
+            BOOST_PROCESS_V2_ASIO_NAMESPACE::post(descriptor.get_executor(),
+                                                  completer{ec, exit_code, std::move(self)});
+
+        }
+
+        template<typename Self>
+        void operator()(Self &&self, error_code ec, int = 0)
+        {
+            native_exit_code_type exit_code{};
+            if (!ec)
+                if (::waitpid(pid_, &exit_code, 0) == -1)
+                    ec = get_last_error();
+            std::move(self).complete(ec, exit_code);
+        }
+    };
+};
+}
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_HANDLE_FD_OR_SIGNAL_HPP

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

@@ -0,0 +1,346 @@
+
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_PROCESS_HANDLE_FD_OR_SIGNAL_HPP
+#define BOOST_PROCESS_V2_DETAIL_PROCESS_HANDLE_FD_OR_SIGNAL_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <boost/process/v2/detail/last_error.hpp>
+#include <boost/process/v2/detail/throw_error.hpp>
+#include <boost/process/v2/exit_code.hpp>
+#include <boost/process/v2/pid.hpp>
+
+#if defined(BOOST_PROCESS_V2_STANDALONE)
+#include <asio/any_io_executor.hpp>
+#include <asio/compose.hpp>
+#include <asio/dispatch.hpp>
+#include <asio/posix/basic_stream_descriptor.hpp>
+#include <asio/post.hpp>
+#include <asio/windows/signal_set.hpp>
+#else
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/posix/basic_stream_descriptor.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/asio/signal_set.hpp>
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace detail
+{
+
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+struct basic_process_handle_fd_or_signal
+{
+    using native_handle_type = int;
+    
+    typedef Executor executor_type;
+
+    executor_type get_executor()
+    { return signal_set_.get_executor(); }
+
+    /// Rebinds the process_handle to another executor.
+    template<typename Executor1>
+    struct rebind_executor
+    {
+        /// The socket type when rebound to the specified executor.
+        typedef basic_process_handle_fd_or_signal<Executor1> other;
+    };
+
+    template<typename ExecutionContext>
+    basic_process_handle_fd_or_signal(ExecutionContext &context,
+                                typename std::enable_if<
+                                        std::is_convertible<ExecutionContext &,
+                                                BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                >::type * = nullptr)
+            : pid_(-1), descriptor_(context)
+    {
+    }
+
+    template<typename ExecutionContext>
+    basic_process_handle_fd_or_signal(ExecutionContext &context,
+                                      pid_type pid,
+                                      typename std::enable_if<
+                                          std::is_convertible<ExecutionContext &,
+                                              BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                          >::type * = nullptr)
+            : pid_(pid), descriptor_(context)
+    {
+    }
+    
+    template<typename ExecutionContext>
+    basic_process_handle_fd_or_signal(ExecutionContext &context,
+                                      pid_type pid, native_handle_type process_handle,
+                                      typename std::enable_if<
+                                          std::is_convertible<ExecutionContext &,
+                                              BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                                          >::type * = nullptr)
+            : pid_(pid), descriptor_(context, process_handle)
+    {
+    }
+    
+
+    basic_process_handle_fd_or_signal(Executor executor)
+            : pid_(-1), descriptor_(executor)
+    {
+    }
+
+    basic_process_handle_fd_or_signal(Executor executor, pid_type pid)
+            : pid_(pid), descriptor_(executor)
+    {
+    }
+
+    basic_process_handle_fd_or_signal(Executor executor, pid_type pid, native_handle_type process_handle)
+            : pid_(pid), descriptor_(executor, process_handle)
+    {
+    }
+
+
+    basic_process_handle_fd_or_signal(basic_process_handle_fd_or_signal &&handle)
+            : pid_(handle.pid_), descriptor_(std::move(handle.descriptor_))
+    {
+        handle.pid_ = -1;
+    }
+    // Warn: does not change the executor of the signal-set.
+    basic_process_handle_fd_or_signal& operator=(basic_process_handle_fd_or_signal &&handle)
+    {
+        pid_ = handle.pid_;
+        descriptor_ = std::move(handle.descriptor_);
+        handle.pid_ = -1;
+        return *this;
+    }
+
+
+    template<typename Executor1>
+    basic_process_handle_fd_or_signal(basic_process_handle_fd_or_signal<Executor1> &&handle)
+            : pid_(handle.pid_), descriptor_(std::move(handle.descriptor_))
+    {
+        handle.pid_ = -1;
+    }
+
+    pid_type id() const
+    { return pid_; }
+
+    void terminate_if_running(error_code &)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::waitpid(pid_, nullptr, WNOHANG) == 0)
+        {
+            ::kill(pid_, SIGKILL);
+            ::waitpid(pid_, nullptr, 0);
+        }
+    }
+
+    void terminate_if_running()
+    {
+        if (pid_ <= 0)
+            return;
+        if (::waitpid(pid_, nullptr, WNOHANG) == 0)
+        {
+            ::kill(pid_, SIGKILL);
+            ::waitpid(pid_, nullptr, 0);
+        }
+    }
+
+    void wait(native_exit_code_type &exit_status, error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        while (::waitpid(pid_, &exit_status, 0) < 0)
+        {
+            if (errno != EINTR)
+            {
+                ec = get_last_error();
+                break;
+            }               
+        }
+            
+    }
+
+    void wait(native_exit_code_type &exit_status)
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        wait(exit_status, ec);
+        if (ec)
+            detail::throw_error(ec, "wait(pid)");
+    }
+
+    void interrupt(error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::kill(pid_, SIGINT) == -1)
+            ec = get_last_error();
+    }
+
+    void interrupt()
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        interrupt(ec);
+        if (ec)
+            detail::throw_error(ec, "interrupt");
+    }
+
+    void request_exit(error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::kill(pid_, SIGTERM) == -1)
+            ec = get_last_error();
+    }
+
+    void request_exit()
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        request_exit(ec);
+        if (ec)
+            detail::throw_error(ec, "request_exit");
+    }
+
+    void terminate(native_exit_code_type &exit_status, error_code &ec)
+    {
+        if (pid_ <= 0)
+            return;
+        if (::kill(pid_, SIGKILL) == -1)
+            ec = get_last_error();
+    }
+
+    void terminate(native_exit_code_type &exit_status)
+    {
+        if (pid_ <= 0)
+            return;
+        error_code ec;
+        terminate(exit_status, ec);
+        if (ec)
+            detail::throw_error(ec, "terminate");
+    }
+
+    bool running(native_exit_code_type &exit_code, error_code & ec)
+    {
+        if (pid_ <= 0)
+            return false;
+        int code = 0;
+        int res = ::waitpid(pid_, &code, WNOHANG);
+        if (res == -1)
+            ec = get_last_error();
+        else
+            ec.clear();
+
+        if (process_is_running(res))
+            return true;
+        else
+        {
+            exit_code = code;
+            return false;
+        }
+    }
+
+    bool running(native_exit_code_type &exit_code)
+    {
+        if (pid_ <= 0)
+            return false;
+
+        error_code ec;
+        bool res = running(exit_code, ec);
+        if (ec)
+            detail::throw_error(ec, "is_running");
+        return res;
+    }
+
+    bool is_open() const
+    {
+        return pid_ != -1;
+    }
+
+    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, int))
+    WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
+    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    {
+        return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                async_wait_op_{descriptor_, signal_set_, pid_}, handler, descriptor_);
+    }
+
+  private:
+    template<typename>
+    friend
+    struct basic_process_handle_fd_or_signal;
+    pid_type pid_ = -1;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_stream_descriptor<Executor> descriptor_;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> signal_set_{descriptor_.get_executor(), SIGCHLD};
+
+    struct async_wait_op_
+    {
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::basic_descriptor<Executor> &descriptor;
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> &handle;
+        pid_type pid_;
+        bool needs_post = true;
+
+        template<typename Self>
+        void operator()(Self &&self, error_code ec = {}, int = 0)
+        {
+            native_exit_code_type exit_code{};
+            int wait_res = -1;
+            if (pid_ <= 0) // error, complete early
+                ec = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
+            else 
+            {
+                wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
+                if (wait_res == -1)
+                    ec = get_last_error();
+            }
+
+            if (!ec && (wait_res == 0))
+            {
+                needs_post = false;
+                if (descriptor.is_open())
+                    descriptor.async_wait(
+                            BOOST_PROCESS_V2_ASIO_NAMESPACE::posix::descriptor_base::wait_read, 
+                            std::move(self));
+                else
+                    handle.async_wait(std::move(self));
+                return;
+            }
+
+            struct completer
+            {
+                error_code ec;
+                native_exit_code_type code;
+                typename std::decay<Self>::type self;
+
+                void operator()()
+                {
+                    self.complete(ec, code);
+                }
+            };
+
+            const auto exec = self.get_executor();
+            completer cpl{ec, exit_code, std::move(self)};
+            if (needs_post)
+                BOOST_PROCESS_V2_ASIO_NAMESPACE::post(exec, std::move(cpl));
+            else
+                BOOST_PROCESS_V2_ASIO_NAMESPACE::dispatch(exec, std::move(cpl));
+
+        }
+    };
+};
+}
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+#endif //BOOST_PROCESS_HANDLE_FD_OR_SIGNAL_HPP

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

@@ -0,0 +1,314 @@
+// Copyright (c) 2022 Klemens D. Morgenstern
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_PROCESS_V2_DETAIL_PROCESS_HANDLE_SIGNAL_HPP
+#define BOOST_PROCESS_V2_DETAIL_PROCESS_HANDLE_SIGNAL_HPP
+
+#include <boost/process/v2/detail/config.hpp>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <boost/process/v2/detail/last_error.hpp>
+#include <boost/process/v2/detail/throw_error.hpp>
+#include <boost/process/v2/exit_code.hpp>
+#include <boost/process/v2/pid.hpp>
+
+#if defined(BOOST_PROCESS_V2_STANDALONE)
+#include <asio/any_io_executor.hpp>
+#include <asio/compose.hpp>
+#include <asio/dispatch.hpp>
+#include <asio/post.hpp>
+#include <asio/signal_set.hpp>
+#else
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/asio/signal_set.hpp>
+#endif
+
+BOOST_PROCESS_V2_BEGIN_NAMESPACE
+
+namespace detail
+{
+
+template<typename Executor = BOOST_PROCESS_V2_ASIO_NAMESPACE::any_io_executor>
+struct basic_process_handle_signal
+{
+    struct native_handle_type
+    {
+         native_handle_type() = delete;
+         native_handle_type(const native_handle_type & ) = delete;
+        ~native_handle_type() = delete;
+    };
+
+    typedef Executor executor_type;
+
+    executor_type get_executor()
+    { return signal_set_.get_executor(); }
+
+    /// Rebinds the process_handle to another executor.
+    template<typename Executor1>
+    struct rebind_executor
+    {
+        /// The socket type when rebound to the specified executor.
+        typedef basic_process_handle_signal<Executor1> other;
+    };
+
+    template<typename ExecutionContext>
+    basic_process_handle_signal(ExecutionContext &context,
+                         typename std::enable_if<
+                                 std::is_convertible<ExecutionContext &,
+                                         BOOST_PROCESS_V2_ASIO_NAMESPACE::execution_context &>::value
+                         >::type * = nullptr)
+            : pid_(-1), signal_set_(context, SIGCHLD)
+    {
+    }
+
+    basic_process_handle_signal(Executor executor)
+            : pid_(-1), signal_set_(executor, SIGCHLD)
+    {
+    }
+
+    basic_process_handle_signal(Executor executor, pid_type pid)
+            : pid_(pid), signal_set_(executor, SIGCHLD)
+    {
+    }
+
+    basic_process_handle_signal(basic_process_handle_signal && handle)
+    : pid_(handle.pid_), signal_set_(handle.signal_set_.get_executor(), SIGCHLD)
+    {
+        handle.pid_ = -1;
+    }
+
+    basic_process_handle_signal& operator=(basic_process_handle_signal && handle)
+    {
+        pid_ = handle.id();
+        signal_set_.~basic_signal_set();
+        using ss = BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor>;
+        new (&signal_set_) ss(handle.get_executor(), SIGCHLD);
+        handle.pid_ = -1;
+        return *this;
+    }
+
+
+    template<typename Executor1>
+    basic_process_handle_signal(basic_process_handle_signal<Executor1> && handle)
+    : pid_(handle.pid_), signal_set_(Executor1(handle.signal_set_.get_executor()), SIGCHLD)
+    {
+        handle.pid_ = -1;
+    }
+
+    pid_type id() const
+    { return pid_; }
+
+    void terminate_if_running(error_code &)
+    {
+         terminate_if_running();
+    }
+
+    void terminate_if_running()
+    {
+        if (pid_ <= 0)
+            return ;
+        if (::waitpid(pid_, nullptr, WNOHANG) == 0)
+        {
+            ::kill(pid_, SIGKILL);
+            ::waitpid(pid_, nullptr, 0);
+        }
+    }
+
+    void wait(native_exit_code_type &exit_status, error_code &ec)
+    {
+        if (pid_ <= 0)
+            return ;
+        while (::waitpid(pid_, &exit_status, 0) < 0)
+        {
+            if (errno != EINTR)
+            {
+                ec = get_last_error();
+                break;
+            }      
+        }
+    }
+
+    void wait(native_exit_code_type &exit_status)
+    {
+        if (pid_ <= 0)
+            return ;
+        error_code ec;
+        wait(exit_status, ec);
+        if (ec)
+            detail::throw_error(ec, "wait(pid)");
+    }
+
+    void interrupt(error_code &ec)
+    {
+        if (pid_ <= 0)
+            return ;
+        if (::kill(pid_, SIGTERM) == -1)
+            ec = get_last_error();
+    }
+
+    void interrupt()
+    {
+        if (pid_ <= 0)
+            return ;
+        error_code ec;
+        interrupt(ec);
+        if (ec)
+            detail::throw_error(ec, "interrupt");
+    }
+
+    void request_exit(error_code &ec)
+    {
+        if (pid_ <= 0)
+            return ;
+        if (::kill(pid_, SIGTERM) == -1)
+            ec = get_last_error();
+    }
+
+    void request_exit()
+    {
+        if (pid_ <= 0)
+            return ;
+        error_code ec;
+        request_exit(ec);
+        if (ec)
+            detail::throw_error(ec, "request_exit");
+    }
+
+    void terminate(native_exit_code_type &exit_status, error_code &ec)
+    {
+        if (pid_ <= 0)
+            return ;
+        if (::kill(pid_, SIGKILL) == -1)
+            ec = get_last_error();
+    }
+
+    void terminate(native_exit_code_type &exit_status)
+    {
+        if (pid_ <= 0)
+            return ;
+        error_code ec;
+        terminate(exit_status, ec);
+        if (ec)
+            detail::throw_error(ec, "terminate");
+    }
+
+    bool running(native_exit_code_type &exit_code, error_code & ec)
+    {
+        if (pid_ <= 0)
+            return false;
+        int code = 0;
+        int res = ::waitpid(pid_, &code, WNOHANG);
+        if (res == -1)
+            ec = get_last_error();
+        
+        if (res == 0)
+            return true;
+        else
+        {
+            exit_code = code;
+            return false;
+        }
+    }
+
+    bool running(native_exit_code_type &exit_code)
+    {
+        if (pid_ <= 0)
+            return false;
+
+        error_code ec;
+        bool res = running(exit_code, ec);
+        if (ec)
+            detail::throw_error(ec, "is_running");
+        return res;
+    }
+
+    bool is_open() const
+    {
+        return pid_ != -1;
+    }
+
+    template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, int))
+    WaitHandler BOOST_PROCESS_V2_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+    BOOST_PROCESS_V2_INITFN_AUTO_RESULT_TYPE(WaitHandler, void (error_code, native_exit_code_type))
+    async_wait(WaitHandler &&handler BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+    {
+        return BOOST_PROCESS_V2_ASIO_NAMESPACE::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
+                async_wait_op_{signal_set_, pid_}, handler, signal_set_);
+    }
+
+  private:
+    template<typename>
+    friend struct basic_process_handle_signal;
+    pid_type pid_ = -1;
+    BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> signal_set_;
+
+    struct async_wait_op_
+    {
+        BOOST_PROCESS_V2_ASIO_NAMESPACE::basic_signal_set<Executor> &handle;
+        pid_type pid_;
+        
+        template<typename Self>
+        void operator()(Self &&self)
+        {
+            handle.async_wait(std::move(self));
+            handle.cancel();
+            // we cancel so we end up on the signal-sets executor 
+        }
+
+        template<typename Self>
+        void operator()(Self &&self, error_code ec, int sig)
+        {
+            if (ec == BOOST_PROCESS_V2_ASIO_NAMESPACE::error::operation_aborted && 
+                self.get_cancellation_state().cancelled() 
+                    == 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 = BOOST_PROCESS_V2_ASIO_NAMESPACE::error::bad_descriptor;
+            else if (!ec)
+            {
+                wait_res = ::waitpid(pid_, &exit_code, WNOHANG);
+                if (wait_res == -1)
+                    ec = get_last_error();
+            }
+
+            if (!ec && (wait_res == 0))
+            {
+                handle.async_wait(std::move(self));
+                return ;
+            }
+
+            struct completer
+            {
+                error_code ec;
+                native_exit_code_type code;
+                typename std::decay<Self>::type self;
+
+                void operator()()
+                {
+                    self.complete(ec, code);
+                }
+            };
+
+            const auto exec = self.get_executor();
+            BOOST_PROCESS_V2_ASIO_NAMESPACE::dispatch(exec, completer{ec, exit_code, std::move(self)});
+        }
+    };
+};
+
+}
+
+
+BOOST_PROCESS_V2_END_NAMESPACE
+
+
+#endif //BOOST_PROCESS_V2_DETAIL_PROCESS_HANDLE_SIGNAL_HPP