fixes the exit-code error on osx builds.

Closes #200.

doc/process.qbk

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

doc/v1.qbk

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

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

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

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

@@ -308,7 +308,7 @@ struct basic_process_handle_win
  public:
     template<BOOST_PROCESS_V2_COMPLETION_TOKEN_FOR(void(error_code, native_exit_code_type))
              WaitHandler = net::default_completion_token_t<executor_type>>
-    auto async_wait(WaitHandler &&handler = default_completion_token_t<executor_type>())
+    auto async_wait(WaitHandler &&handler = net::default_completion_token_t<executor_type>())
         -> decltype(net::async_compose<WaitHandler, void(error_code, native_exit_code_type)>(
                     async_wait_op_{handle_}, handler, handle_))
     {

include/boost/process/v2/experimental/basic_stream_input.hpp

@@ -1,23 +0,0 @@
-//
-// Copyright (c) 2024 Klemens Morgenstern (klemens.morgenstern@gmx.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_BASIC_STREAM_INPUT_HPP
-#define BOOST_PROCESS_BASIC_STREAM_INPUT_HPP
-
-#include <boost/process/v2/detail/config.hpp>
-
-BOOST_PROCESS_V2_BEGIN_NAMESPACE
-
-
-
-
-template<typename Executor>
-basic_stream_input<Executor> open_stdin(Executor executor, bool duplicate = true);
-
-BOOST_PROCESS_V2_END_NAMESPACE
-
-#endif //BOOST_PROCESS_BASIC_STREAM_INPUT_HPP

include/boost/process/v2/experimental/stream_input.hpp

@@ -1,21 +0,0 @@
-//
-// Copyright (c) 2024 Klemens Morgenstern (klemens.morgenstern@gmx.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_EXPERIMENTAL_STREAM_INPUT_HPP
-#define BOOST_PROCESS_V2_EXPERIMENTAL_STREAM_INPUT_HPP
-
-#include <boost/process/v2/detail/config.hpp>
-#include <boost/process/v2/experimental/basic_stream_input.hpp>
-
-
-BOOST_PROCESS_V2_BEGIN_NAMESPACE
-
-typedef basic_stream_input<> stream_input;
-
-BOOST_PROCESS_V2_END_NAMESPACE
-
-#endif //BOOST_PROCESS_V2_EXPERIMENTAL_STREAM_INPUT_HPP

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

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

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

@@ -8,6 +8,7 @@
 #define BOOST_PROCESS_V2_ENV_HPP
 #include <string>
 #include <vector>
+#include <memory>
 
 #include <boost/process/v2/detail/config.hpp>
 #include <boost/process/v2/detail/throw_error.hpp>
@@ -26,9 +27,6 @@ namespace ext
 #if defined(BOOST_PROCESS_V2_WINDOWS)
 using native_env_handle_type = wchar_t *;
 using native_env_iterator = wchar_t *;
-#elif defined(__FreeBSD__)
-using native_env_handle_type = char **;
-using native_env_iterator = char **;
 #else
 using native_env_handle_type = char *;
 using native_env_iterator = char *;

include/boost/process/v2/pid.hpp

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

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

@@ -29,7 +29,7 @@
 #include <unistd.h>
 
 
-#if defined(__APPLE__) || defined(__MACH__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#if defined(__APPLE__) || defined(__MACH__) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun)
 extern "C" { extern char **environ; }
 #endif
 

src/ext/cmd.cpp

@@ -52,6 +52,7 @@
 #endif
 
 #if defined(__sun)
+#include <cstdlib>
 #include <sys/types.h>
 #include <kvm.h>
 #include <sys/param.h>
@@ -274,6 +275,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -283,7 +285,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     };
 
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return {};}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp))) 
     {
         char **cmd = kvm_getargv(kd.get(), proc_info, 0);
@@ -301,10 +303,9 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
 shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-
-    std::vector<std::string> vec;
     int cntp = 0;
     kinfo_proc2 *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -315,7 +316,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
 
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return vec;}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
     if ((proc_info = kvm_getproc2(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc2), &cntp))) 
     {
         char **cmd = kvm_getargv2(kd.get(), proc_info, 0);
@@ -326,14 +327,13 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     }
     else
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-    return vec;
+    return {};
 }
     
 #elif defined(__OpenBSD__)
 
 shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-    std::vector<std::string> vec;
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
 
@@ -346,7 +346,7 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     };
 
     std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return vec;}
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
     if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc), &cntp))) 
     {
         char **cmd = kvm_getargv(kd.get(), proc_info, 0);
@@ -367,22 +367,29 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     char **cmd = nullptr;
     proc *proc_info = nullptr;
     user *proc_user = nullptr;
-    kvm_t *kd = kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr);
-    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return {};}
-    if ((proc_info = kvm_getproc(kd, pid))) 
+
+    struct closer
     {
-        if ((proc_user = kvm_getu(kd, proc_info))) 
+        void operator()(kvm_t * kd)
         {
-            if (!kvm_getcmd(kd, proc_info, proc_user, &cmd, nullptr)) 
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
+    if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+    if ((proc_info = kvm_getproc(kd.get(), pid))) 
+    {
+        if ((proc_user = kvm_getu(kd.get(), proc_info))) 
+        {
+            if (!kvm_getcmd(kd.get(), proc_info, proc_user, &cmd, nullptr)) 
             {
                 int argc = 0;
                 for (int i = 0; cmd[i] != nullptr; i++)
-                    argc ++;
-                shell res = make_cmd_shell_::make(
+                    argc++;
+                return make_cmd_shell_::make(
                         {}, argc, cmd,
-                        +[](int, char ** argv) {::free(argv);})
-                kvm_close(kd);
-                return res;
+                        +[](int, char ** argv) {::free(argv);});
             }
             else
                 BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
@@ -392,8 +399,6 @@ shell cmd(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     }
     else
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-    
-    kvm_close(kd);
     return {};
 }
 

src/ext/env.cpp

@@ -23,6 +23,7 @@
 #if (defined(__APPLE__) && defined(__MACH__))
 #include <TargetConditionals.h>
 #if !TARGET_OS_IOS
+  #include <algorithm>
   #include <sys/proc_info.h>
   #include <sys/sysctl.h>
   #include <libproc.h>
@@ -34,21 +35,52 @@
 #endif
 
 #if defined(__FreeBSD__)
-#include <sys/socket.h>
-#include <sys/sysctl.h>
+#include <algorithm>
+#include <cstring>
+#include <fcntl.h>
+#include <kvm.h>
 #include <sys/param.h>
-#include <sys/queue.h>
+#include <sys/sysctl.h>
 #include <sys/user.h>
-#include <libprocstat.h>
+#endif
+
+#if defined(__DragonFly__)
+#include <algorithm>
+#include <cstring>
+#include <sys/types.h>
+#include <kvm.h>
+#endif
+
+#if defined(__NetBSD__)
+#include <algorithm>
+#include <cstring>
+#include <fcntl.h>
+#include <kvm.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
 #endif
 
 #if defined(__OpenBSD__)
+#include <algorithm>
+#include <cstring>
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <fcntl.h>
 #include <kvm.h>
 #endif
 
+#if defined(__sun)
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <kvm.h>
+#include <fcntl.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/user.h>
+#include <sys/proc.h>
+#endif
+
 BOOST_PROCESS_V2_BEGIN_NAMESPACE
 
 namespace detail {
@@ -105,7 +137,7 @@ const environment::char_type * dereference(native_env_iterator iterator)
     return iterator;
 }
 
-#elif (defined(__APPLE___) || defined(__MACH__)) || defined(__OpenBSD__)
+#elif (defined(__APPLE___) || defined(__MACH__)) || defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__sun)
 
 void native_env_handle_deleter::operator()(native_env_handle_type h) const
 {
@@ -130,31 +162,6 @@ const environment::char_type * dereference(native_env_iterator iterator)
     return iterator;
 }
 
-
-#elif defined(__FreeBSD__)
-
-void native_env_handle_deleter::operator()(native_env_handle_type h) const
-{
-    delete [] h;
-}
-
-native_env_iterator next(native_env_iterator nh)
-{
-    return ++nh ;
-}
-native_env_iterator find_end(native_env_iterator nh)
-{
-    while (*nh != nullptr)
-      nh++;
-
-    return nh ;
-}
-
-const environment::char_type * dereference(native_env_iterator iterator)
-{
-    return *iterator;
-}
-
 #endif
 
 }
@@ -338,72 +345,90 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
     return ev;
 }
 
-#elif defined(__FreeBSD__)
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
 env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-  env_view ev;
+  std::vector<char> vec;
+  int cntp = 0;
+  kinfo_proc *proc_info = nullptr;
+  const char *nlistf, *memf;
+  nlistf = memf = "/dev/null";
 
-  unsigned cntp = 0;
-  procstat *proc_stat = procstat_open_sysctl();
-  if (proc_stat != nullptr)
+  struct closer
   {
-    kinfo_proc *proc_info = procstat_getprocs(proc_stat, KERN_PROC_PID, pid, &cntp);
-    if (proc_info != nullptr)
+    void operator()(kvm_t * kd)
     {
-      char **env = procstat_getenvv(proc_stat, proc_info, 0);
-      if (env != nullptr)
+      kvm_close(kd);
+    }
+  };
+
+  std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+  if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp))) {
+    char **env = kvm_getenvv(kd.get(), proc_info, 0);
+    if (env) {
+      for (int i = 0; env[i] != nullptr; i++) 
       {
-        auto e = env;
-        std::size_t n = 0u, len = 0u;
-        while (e && *e != nullptr)
-        {
-          n ++;
-          len += std::strlen(*e);
-          e++;
-        }
-        std::size_t mem_needed =
-            // environ         -  nullptr       - strlen  + null terminators
-            (n * sizeof(char*)) + sizeof(char*) + len     + n;
-
-        char * out = new (std::nothrow) char[mem_needed];
-        if (out != nullptr)
-        {
-          auto eno = reinterpret_cast<char**>(out);
-          auto eeo = eno;
-            auto str = out +  (n * sizeof(char*)) + sizeof(char*);
-          e = env;
-          while (*e != nullptr)
-          {
-            auto len = std::strlen(*e) + 1u;
-            std::memcpy(str, *e, len);
-            *eno = str;
-            str += len;
-            eno ++;
-            e++;
-          }
-          *eno = nullptr;
-
-          ev.handle_.reset(eeo);
-        }
-        else
-            BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-
+        for (int j = 0; j < strlen(env[i]); j++)
+          vec.push_back(env[i][j]);
+        vec.push_back('\0');
       }
-      procstat_freeprocs(proc_stat, proc_info);
-
+      vec.push_back('\0');
     }
     else
       BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
-    procstat_close(proc_stat);
   }
   else
     BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
+  env_view ev;
+  ev.handle_.reset(new char[vec.size()]());
+  std::copy(vec.begin(), vec.end(), ev.handle_.get());
+  return ev;
+}
+
+#elif defined(__NetBSD__)
+env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+{
+  std::vector<char> vec;
+  int cntp = 0;
+  kinfo_proc2 *proc_info = nullptr;
+
+  struct closer
+  {
+    void operator()(kvm_t * kd)
+    {
+      kvm_close(kd);
+    }
+  };
+
+  std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+  if ((proc_info = kvm_getproc2(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc2), &cntp))) {
+    char **env = kvm_getenvv2(kd.get(), proc_info, 0);
+    if (env) {
+      for (int i = 0; env[i] != nullptr; i++) 
+      {
+        for (int j = 0; j < strlen(env[i]); j++)
+          vec.push_back(env[i][j]);
+        vec.push_back('\0');
+      }
+      vec.push_back('\0');
+    }
+    else
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+  }
+  else
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
+  env_view ev;
+  ev.handle_.reset(new char[vec.size()]());
+  std::copy(vec.begin(), vec.end(), ev.handle_.get());
   return ev;
 }
 #elif defined(__OpenBSD__)
 env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
 {
-
   std::vector<char> vec;
   int cntp = 0;
   kinfo_proc *proc_info = nullptr;
@@ -417,7 +442,7 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
   };
 
   std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nullptr, nullptr, nullptr, KVM_NO_FILES, nullptr)};
-  if (!kd.get()) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec) return {};}
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
   if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, sizeof(struct kinfo_proc), &cntp)))
   {
     char **env = kvm_getenvv(kd.get(), proc_info, 0);
@@ -442,6 +467,53 @@ env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
   std::copy(vec.begin(), vec.end(), ev.handle_.get());
   return ev;
 }
+#elif defined(__sun)
+env_view env(boost::process::v2::pid_type pid, boost::system::error_code & ec)
+{
+  std::vector<char> vec;
+  char **env = nullptr;
+  proc *proc_info = nullptr;
+  user *proc_user = nullptr;
+
+  struct closer
+  {
+    void operator()(kvm_t * kd)
+    {
+      kvm_close(kd);
+    }
+  };
+
+  std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
+  if (!kd) {BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec); return {};}
+  if ((proc_info = kvm_getproc(kd.get(), pid))) 
+  {
+    if ((proc_user = kvm_getu(kd.get(), proc_info))) 
+    {
+      if (!kvm_getcmd(kd.get(), proc_info, proc_user, nullptr, &env)) 
+      {
+        for (int i = 0; env[i] != nullptr; i++) 
+        {
+          for (int j = 0; j < strlen(env[i]); j++)
+            vec.push_back(env[i][j]);
+          vec.push_back('\0');
+        }
+        vec.push_back('\0');
+        free(env);
+      }
+      else
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+    }
+    else
+      BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+  }
+  else
+    BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+
+  env_view ev;
+  ev.handle_.reset(new char[vec.size()]());
+  std::copy(vec.begin(), vec.end(), ev.handle_.get());
+  return ev;
+}
 #endif
 
 env_view env(boost::process::v2::pid_type pid)

src/ext/exe.cpp

@@ -39,7 +39,7 @@
 #if (defined(__FreeBSD__) || defined(__DragonFly__) || defined(__NetBSD__))
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 #include <alloca.h>
 #endif
 #endif

src/pid.cpp

@@ -29,10 +29,11 @@
 #endif
 
 #if defined(__FreeBSD__)
-#include <sys/types.h>
+#include <fcntl.h>
+#include <kvm.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
 #include <sys/user.h>
-#include <libutil.h>
-#include <cstdlib>
 #endif
 
 #if (defined(__DragonFly__) ||  defined(__OpenBSD__))
@@ -51,6 +52,7 @@
 #endif
 
 #if defined(__sun)
+#include <fcntl.h>
 #include <sys/types.h>
 #include <kvm.h>
 #include <sys/param.h>
@@ -277,13 +279,29 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
 {
     std::vector<pid_type> vec;
     int cntp = 0;
-    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
-    if (proc_info) 
+    kinfo_proc *proc_info = nullptr;
+    const char *nlistf, *memf;
+    nlistf = memf = "/dev/null";
+  
+    struct closer
+    {
+        void operator()(kvm_t * kd)
+        {
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
+    if (!kd) 
+    {
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        return vec;
+    }
+    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp))) 
     {
         vec.reserve(cntp);
-        for (int i = 0; i < cntp; i++)
+        for (int i = 0; i < cntp; i++) 
             vec.push_back(proc_info[i].ki_pid);
-        free(proc_info);
     }
     else
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
@@ -293,11 +311,28 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
 pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
 {
     pid_type ppid = static_cast<pid_type>(-1);
-    kinfo_proc *proc_info = kinfo_getproc(pid);
-    if (proc_info)
+    int cntp = 0;
+    kinfo_proc *proc_info = nullptr;
+    const char *nlistf, *memf;
+    nlistf = memf = "/dev/null";
+  
+    struct closer
+    {
+        void operator()(kvm_t * kd)
+        {
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)}; 
+    if (!kd) 
+    {
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        return ppid;
+    }
+    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_PID, pid, &cntp)))
     {
         ppid = proc_info->ki_ppid;
-        free(proc_info);
     }
     else
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
@@ -307,9 +342,26 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
 std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec) 
 {
     std::vector<pid_type> vec;
-    int cntp = 0; 
-    kinfo_proc *proc_info = kinfo_getallproc(&cntp);
-    if (proc_info)
+    int cntp = 0;
+    kinfo_proc *proc_info = nullptr;
+    const char *nlistf, *memf;
+    nlistf = memf = "/dev/null";
+  
+    struct closer
+    {
+        void operator()(kvm_t * kd)
+        {
+            kvm_close(kd);
+        }
+    };
+
+    std::unique_ptr<kvm_t, closer> kd{kvm_openfiles(nlistf, memf, nullptr, O_RDONLY, nullptr)};
+    if (!kd) 
+    {
+        BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
+        return vec;
+    }
+    if ((proc_info = kvm_getprocs(kd.get(), KERN_PROC_ALL, 0, &cntp)))
     {
         vec.reserve(cntp);
         for (int i = 0; i < cntp; i++)
@@ -319,7 +371,6 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
                 vec.push_back(proc_info[i].ki_pid);
             }
         }
-        free(proc_info);
     }
     else
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
@@ -335,6 +386,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -368,6 +420,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -401,6 +454,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     kinfo_proc *proc_info = nullptr;
     const char *nlistf, *memf;
     nlistf = memf = "/dev/null";
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -438,6 +492,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc2  *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -470,6 +525,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     pid_type ppid = static_cast<pid_type>(-1);
     int cntp = 0;
     kinfo_proc2 *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -498,6 +554,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc2 *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -535,6 +592,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -570,6 +628,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
     pid_type ppid = static_cast<pid_type>(-1);
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -598,6 +657,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::vector<pid_type> vec;
     int cntp = 0;
     kinfo_proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -636,6 +696,7 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
     std::vector<pid_type> vec;
     struct pid cur_pid;
     proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -650,9 +711,9 @@ std::vector<pid_type> all_pids(boost::system::error_code & ec)
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     } 
-    while ((proc_info = kvm_nextproc(kd)))
+    while ((proc_info = kvm_nextproc(kd.get())))
     {
-        if (kvm_kread(kd, (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
+        if (kvm_kread(kd.get(), (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
         {
             vec.insert(vec.begin(), cur_pid.pid_id);
         }
@@ -669,6 +730,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
 {
     pid_type ppid = static_cast<pid_type>(-1);
     proc *proc_info = nullptr;
+  
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -683,7 +745,7 @@ pid_type parent_pid(pid_type pid, boost::system::error_code & ec)
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return ppid;
     }
-    if ((proc_info = kvm_getproc(kd, pid)))
+    if ((proc_info = kvm_getproc(kd.get(), pid)))
     {
         ppid = proc_info->p_ppid;
     }
@@ -697,6 +759,7 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
     std::vector<pid_type> vec;
     struct pid cur_pid;
     proc *proc_info = nullptr;
+
     struct closer
     {
         void operator()(kvm_t * kd)
@@ -705,17 +768,17 @@ std::vector<pid_type> child_pids(pid_type pid, boost::system::error_code & ec)
         }
     };
 
-    std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr);
+    std::unique_ptr<kvm_t, closer> kd{kvm_open(nullptr, nullptr, nullptr, O_RDONLY, nullptr)};
     if (!kd)
     {
         BOOST_PROCESS_V2_ASSIGN_LAST_ERROR(ec);
         return vec;
     }
-    while ((proc_info = kvm_nextproc(kd)))
+    while ((proc_info = kvm_nextproc(kd.get())))
     {
         if (proc_info->p_ppid == pid)
         {
-            if (kvm_kread(kd, (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
+            if (kvm_kread(kd.get(), (std::uintptr_t)proc_info->p_pidp, &cur_pid, sizeof(cur_pid)) != -1)
             {
                 vec.insert(vec.begin(), cur_pid.pid_id);
             }

test/v1/exit_code.cpp

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

test/v2/Jamfile.jam

@@ -21,9 +21,7 @@ project : requirements
   <target-os>windows:<define>_WIN32_WINNT=0x0601
   <target-os>linux:<linkflags>-lpthread
   <target-os>freebsd:<linkflags>-lpthread
-  <target-os>freebsd:<linkflags>-lutil
   <target-os>freebsd:<linkflags>-lkvm
-  <target-os>freebsd:<linkflags>-lprocstat
   <target-os>bsd:<linkflags>-lpthread
   <target-os>bsd:<linkflags>-lkvm
   <target-os>netbsd:<linkflags>-lpthread