common,agent,gpg,dirmngr,g13,scd,tests,tools: New spawn function.

* common/exechelp-posix.c (do_exec, gnupg_spawn_process): Remove.
(check_syscall_func, pre_syscall, post_syscall) : New.
(do_create_socketpair, posix_open_null, call_spawn_cb): New.
(my_exec, spawn_detached, gnupg_spawn_helper): New.
(gnupg_process_spawn, process_kill, gnupg_process_terminate): New.
(gnupg_process_get_fds, gnupg_process_get_streams): New.
(process_vctl, gnupg_process_ctl): New.
(gnupg_process_wait, gnupg_process_release): New.
(gnupg_process_wait_list): New.
* common/exechelp-w32.c: Add definition of _WIN32_WINNT as 0x600.
(check_syscall_func, pre_syscall, post_syscall): New.
(gnupg_spawn_process): Remove.
(check_windows_version): New.
(spawn_detached, gnupg_spawn_helper, gnupg_process_spawn): New.
(gnupg_process_get_fds, gnupg_process_get_streams): New.
(process_kill, process_vctl, gnupg_process_ctl): New.
(gnupg_process_wait, gnupg_process_terminate): New.
(gnupg_process_release, gnupg_process_wait_list): New.
* common/exechelp.h: Re-write for new API.
* common/exectool.c (gnupg_exec_tool_stream): Follow the change.
* common/asshelp.c (start_new_service): Likewise.
* agent/genkey.c (do_check_passphrase_pattern): Likewise.
* dirmngr/ldap-wrapper.c (struct wrapper_context_s): Use PROC.
(destroy_wrapper): Follow the change of API.
(read_log_data): Follow the change of API, use printable_pid.
(ldap_reaper_thread, ldap_wrapper_release_context): Likewise.
(ldap_wrapper_connection_cleanup, ldap_wrapper): Likewise.
* g10/photoid.c (run_with_pipe): Follow the change of API.
(show_photo): Likewise.
* g13/be-encfs.c (run_umount_helper): Likewise.
(run_encfs_tool): Likewise.
* g13/g13.c: Add including ./common/exechelp.h.
* g13/mount.c: Likewise.
* g13/runner.c: Follow the change of API.
* g13/runner.h: Follow the change of API.
* scd/app.c (setup_env): New.
(report_change): Follow the change of API.
* tests/gpgscm/ffi.c (proc_object_finalize): New.
(proc_object_to_string): New.
(proc_wrap, proc_unwrap): New.
(do_spawn_process): Remove.
(do_process_spawn): New.
(setup_std_fds): New.
(do_spawn_process_fd): Remove.
(do_process_spawn_fd): New.
(do_wait_process): Remove.
(do_process_wait): New.
(do_wait_processes): Remove.
* tests/gpgscm/t-child.scm: Follow the change of API.
* tests/gpgscm/tests.scm: Likewise.
* tests/openpgp/defs.scm: Likewise.
* tests/tpm2dtests/defs.scm: Likewise.
* tools/gpg-card.c: Likewise.
* tools/gpgconf-comp.c: Likewise.
* tools/gpgconf.c: Likewise.
* tools/gpgtar-create.c: Likewise.
* tools/gpgtar-extract.c: Likewise.
* tools/gpgtar-list.c: Likewise.

--

GnuPG-bug-id: 6275
Signed-off-by: NIIBE Yutaka <[email protected]>

1 files changed, 696 insertions, 510 deletions

diff --git a/common/exechelp-w32.c b/common/exechelp-w32.c
index 0034e03f2..8057cc3b4 100644
--- a/common/exechelp-w32.c
+++ b/common/exechelp-w32.c
@@ -33,6 +33,8 @@
 
 #if !defined(HAVE_W32_SYSTEM)
 #error This code is only used on W32.
+#else
+#define _WIN32_WINNT 0x600
 #endif
 
 #include <stdio.h>
@@ -63,9 +65,11 @@
 #include "util.h"
 #include "i18n.h"
 #include "sysutils.h"
+#define NEED_STRUCT_SPAWN_CB_ARG
 #include "exechelp.h"
 
 #include <windows.h>
+#include <processthreadsapi.h>
 
 /* Define to 1 do enable debugging.  */
 #define DEBUG_W32_SPAWN 0
@@ -405,143 +409,145 @@ gnupg_close_pipe (int fd)
   if (fd != -1)
     close (fd);
 }
+
+struct gnupg_process {
+  const char *pgmname;
+  unsigned int terminated   :1; /* or detached */
+  unsigned int flags;
+  HANDLE hProcess;
+  HANDLE hd_in;
+  HANDLE hd_out;
+  HANDLE hd_err;
+  int exitcode;
+};
+
+static int gnupg_process_syscall_func_initialized;
+
+/* Functions called before and after blocking syscalls.  */
+static void (*pre_syscall_func) (void);
+static void (*post_syscall_func) (void);
+
+static void
+check_syscall_func (void)
+{
+  if (!gnupg_process_syscall_func_initialized)
+    {
+      gpgrt_get_syscall_clamp (&pre_syscall_func, &post_syscall_func);
+      gnupg_process_syscall_func_initialized = 1;
+    }
+}
 
+static void
+pre_syscall (void)
+{
+  if (pre_syscall_func)
+    pre_syscall_func ();
+}
 
-/* Fork and exec the PGMNAME, see exechelp.h for details.  */
-gpg_error_t
-gnupg_spawn_process (const char *pgmname, const char *argv[],
-                     int *except, unsigned int flags,
-                     estream_t *r_infp,
-                     estream_t *r_outfp,
-                     estream_t *r_errfp,
-                     pid_t *pid)
+static void
+post_syscall (void)
 {
-  gpg_error_t err;
-  SECURITY_ATTRIBUTES sec_attr;
-  PROCESS_INFORMATION pi =
-    {
-      NULL,      /* Returns process handle.  */
-      0,         /* Returns primary thread handle.  */
-      0,         /* Returns pid.  */
-      0          /* Returns tid.  */
-    };
-  STARTUPINFOW si;
-  int cr_flags;
-  char *cmdline;
-  wchar_t *wcmdline = NULL;
-  wchar_t *wpgmname = NULL;
-  HANDLE inpipe[2]  = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
-  HANDLE outpipe[2] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
-  HANDLE errpipe[2] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
-  estream_t infp = NULL;
-  estream_t outfp = NULL;
-  estream_t errfp = NULL;
-  HANDLE nullhd[3] = {INVALID_HANDLE_VALUE,
-                      INVALID_HANDLE_VALUE,
-                      INVALID_HANDLE_VALUE};
-  int i, rc;
-  es_syshd_t syshd;
-  gpg_err_source_t errsource = default_errsource;
-  int nonblock = !!(flags & GNUPG_SPAWN_NONBLOCK);
+  if (post_syscall_func)
+    post_syscall_func ();
+}
 
-  (void)except; /* Not yet used.  */
 
-  if (r_infp)
-    *r_infp = NULL;
-  if (r_outfp)
-    *r_outfp = NULL;
-  if (r_errfp)
-    *r_errfp = NULL;
-  *pid = (pid_t)(-1); /* Always required.  */
+/*
+ * Check if STARTUPINFOEXW supports PROC_THREAD_ATTRIBUTE_HANDLE_LIST.
+ */
+static int
+check_windows_version (void)
+{
+  static int is_vista_or_later = -1;
+
+  OSVERSIONINFO osvi;
 
-  if (r_infp)
+  if (is_vista_or_later == -1)
     {
-      if (create_inheritable_pipe (inpipe, INHERIT_READ))
-        {
-          err = gpg_err_make (errsource, GPG_ERR_GENERAL);
-          log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
-          return err;
-        }
+      memset (&osvi,0,sizeof(osvi));
+      osvi.dwOSVersionInfoSize = sizeof(osvi);
+      GetVersionEx (&osvi);
 
-      syshd.type = ES_SYSHD_HANDLE;
-      syshd.u.handle = inpipe[1];
-      infp = es_sysopen (&syshd, nonblock? "w,nonblock" : "w");
-      if (!infp)
-        {
-          err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
-          log_error (_("error creating a stream for a pipe: %s\n"),
-                     gpg_strerror (err));
-          CloseHandle (inpipe[0]);
-          CloseHandle (inpipe[1]);
-          inpipe[0] = inpipe[1] = INVALID_HANDLE_VALUE;
-          return err;
-        }
+      /* The feature is available on Vista or later.  */
+      is_vista_or_later = (osvi.dwMajorVersion >= 6);
     }
 
-  if (r_outfp)
-    {
-      if (create_inheritable_pipe (outpipe, INHERIT_WRITE))
-        {
-          err = gpg_err_make (errsource, GPG_ERR_GENERAL);
-          log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
-          return err;
-        }
+  return is_vista_or_later;
+}
 
-      syshd.type = ES_SYSHD_HANDLE;
-      syshd.u.handle = outpipe[0];
-      outfp = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
-      if (!outfp)
-        {
-          err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
-          log_error (_("error creating a stream for a pipe: %s\n"),
-                     gpg_strerror (err));
-          CloseHandle (outpipe[0]);
-          CloseHandle (outpipe[1]);
-          outpipe[0] = outpipe[1] = INVALID_HANDLE_VALUE;
-          if (infp)
-            es_fclose (infp);
-          else if (inpipe[1] != INVALID_HANDLE_VALUE)
-            CloseHandle (inpipe[1]);
-          if (inpipe[0] != INVALID_HANDLE_VALUE)
-            CloseHandle (inpipe[0]);
-          return err;
-        }
+
+static gpg_err_code_t
+spawn_detached (const char *pgmname, char *cmdline,
+                void (*spawn_cb) (struct spawn_cb_arg *), void *spawn_cb_arg)
+{
+  SECURITY_ATTRIBUTES sec_attr;
+  PROCESS_INFORMATION pi = { NULL, 0, 0, 0 };
+  STARTUPINFOEXW si;
+  int cr_flags;
+  wchar_t *wcmdline = NULL;
+  wchar_t *wpgmname = NULL;
+  gpg_err_code_t ec;
+  int ret;
+  struct spawn_cb_arg sca;
+  BOOL ask_inherit = FALSE;
+
+  ec = gnupg_access (pgmname, X_OK);
+  if (ec)
+    {
+      xfree (cmdline);
+      return ec;
     }
 
-  if (r_errfp)
+  memset (&si, 0, sizeof si);
+
+  sca.allow_foreground_window = FALSE;
+  sca.hd[0] = INVALID_HANDLE_VALUE;
+  sca.hd[1] = INVALID_HANDLE_VALUE;
+  sca.hd[2] = INVALID_HANDLE_VALUE;
+  sca.inherit_hds = NULL;
+  sca.arg = spawn_cb_arg;
+  if (spawn_cb)
+    (*spawn_cb) (&sca);
+
+  if (sca.inherit_hds)
     {
-      if (create_inheritable_pipe (errpipe, INHERIT_WRITE))
-        {
-          err = gpg_err_make (errsource, GPG_ERR_GENERAL);
-          log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
-          return err;
-        }
+      SIZE_T attr_list_size = 0;
+      HANDLE hd[16];
+      HANDLE *hd_p = sca.inherit_hds;
+      int j = 0;
 
-      syshd.type = ES_SYSHD_HANDLE;
-      syshd.u.handle = errpipe[0];
-      errfp = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
-      if (!errfp)
+      if (hd_p)
         {
-          err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
-          log_error (_("error creating a stream for a pipe: %s\n"),
-                     gpg_strerror (err));
-          CloseHandle (errpipe[0]);
-          CloseHandle (errpipe[1]);
-          errpipe[0] = errpipe[1] = INVALID_HANDLE_VALUE;
-          if (outfp)
-            es_fclose (outfp);
-          else if (outpipe[0] != INVALID_HANDLE_VALUE)
-            CloseHandle (outpipe[0]);
-          if (outpipe[1] != INVALID_HANDLE_VALUE)
-            CloseHandle (outpipe[1]);
-          if (infp)
-            es_fclose (infp);
-          else if (inpipe[1] != INVALID_HANDLE_VALUE)
-            CloseHandle (inpipe[1]);
-          if (inpipe[0] != INVALID_HANDLE_VALUE)
-            CloseHandle (inpipe[0]);
-          return err;
+          while (*hd_p != INVALID_HANDLE_VALUE)
+            if (j < DIM (hd))
+              hd[j++] = *hd_p++;
+            else
+              {
+                log_error ("Too much handles\n");
+                break;
+              }
         }
+
+      if (j)
+	{
+	  if (check_windows_version ())
+	    {
+	      InitializeProcThreadAttributeList (NULL, 1, 0, &attr_list_size);
+	      si.lpAttributeList = xtrymalloc (attr_list_size);
+	      if (si.lpAttributeList == NULL)
+		{
+		  xfree (cmdline);
+		  return gpg_err_code_from_syserror ();
+		}
+	      InitializeProcThreadAttributeList (si.lpAttributeList, 1, 0,
+						 &attr_list_size);
+	      UpdateProcThreadAttribute (si.lpAttributeList, 0,
+					 PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
+					 hd, sizeof (HANDLE) * j, NULL, NULL);
+	    }
+
+	  ask_inherit = TRUE;
+	}
     }
 
   /* Prepare security attributes.  */
@@ -549,502 +555,682 @@ gnupg_spawn_process (const char *pgmname, const char *argv[],
   sec_attr.nLength = sizeof sec_attr;
   sec_attr.bInheritHandle = FALSE;
 
-  /* Build the command line.  */
-  err = build_w32_commandline (pgmname, argv, &cmdline);
-  if (err)
-    return err;
-
-  if (inpipe[0] == INVALID_HANDLE_VALUE)
-    nullhd[0] = ((flags & GNUPG_SPAWN_KEEP_STDIN)?
-                 GetStdHandle (STD_INPUT_HANDLE) : w32_open_null (0));
-  if (outpipe[1] == INVALID_HANDLE_VALUE)
-    nullhd[1] = ((flags & GNUPG_SPAWN_KEEP_STDOUT)?
-                 GetStdHandle (STD_OUTPUT_HANDLE) : w32_open_null (1));
-  if (errpipe[1] == INVALID_HANDLE_VALUE)
-    nullhd[2] = ((flags & GNUPG_SPAWN_KEEP_STDOUT)?
-                 GetStdHandle (STD_ERROR_HANDLE) : w32_open_null (1));
-
-  memset (&si, 0, sizeof si);
-  si.cb = sizeof (si);
-  si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
-  si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_HIDE;
-  si.hStdInput  = inpipe[0]  == INVALID_HANDLE_VALUE? nullhd[0] : inpipe[0];
-  si.hStdOutput = outpipe[1] == INVALID_HANDLE_VALUE? nullhd[1] : outpipe[1];
-  si.hStdError  = errpipe[1] == INVALID_HANDLE_VALUE? nullhd[2] : errpipe[1];
+  /* Start the process.  */
+  si.StartupInfo.cb = sizeof (si);
+  si.StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
+  si.StartupInfo.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
 
   cr_flags = (CREATE_DEFAULT_ERROR_MODE
-              | ((flags & GNUPG_SPAWN_DETACHED)? DETACHED_PROCESS : 0)
               | GetPriorityClass (GetCurrentProcess ())
-              | CREATE_SUSPENDED);
-  /*   log_debug ("CreateProcess, path='%s' cmdline='%s'\n", */
-  /*              pgmname, cmdline); */
+              | CREATE_NEW_PROCESS_GROUP
+              | DETACHED_PROCESS);
+
   /* Take care: CreateProcessW may modify wpgmname */
   if (!(wpgmname = utf8_to_wchar (pgmname)))
-    rc = 0;
+    ret = 0;
   else if (!(wcmdline = utf8_to_wchar (cmdline)))
-    rc = 0;
+    ret = 0;
   else
-    rc = CreateProcessW (wpgmname,      /* Program to start.  */
-                         wcmdline,      /* Command line arguments.  */
-                         &sec_attr,     /* Process security attributes.  */
-                         &sec_attr,     /* Thread security attributes.  */
-                         TRUE,          /* Inherit handles.  */
-                         cr_flags,      /* Creation flags.  */
-                         NULL,          /* Environment.  */
-                         NULL,          /* Use current drive/directory.  */
-                         &si,           /* Startup information. */
-                         &pi            /* Returns process information.  */
-                         );
-  if (!rc)
+    ret = CreateProcessW (wpgmname,      /* Program to start.  */
+                          wcmdline,      /* Command line arguments.  */
+                          &sec_attr,     /* Process security attributes.  */
+                          &sec_attr,     /* Thread security attributes.  */
+                          ask_inherit,   /* Inherit handles.  */
+                          cr_flags,      /* Creation flags.  */
+                          NULL,          /* Environment.  */
+                          NULL,          /* Use current drive/directory.  */
+                          (STARTUPINFOW *)&si,           /* Startup information. */
+                          &pi            /* Returns process information.  */
+                          );
+  if (!ret)
     {
       if (!wpgmname || !wcmdline)
         log_error ("CreateProcess failed (utf8_to_wchar): %s\n",
                    strerror (errno));
       else
-        log_error ("CreateProcess failed: %s\n", w32_strerror (-1));
+        log_error ("CreateProcess(detached) failed: %d\n",
+                   (int)GetLastError ());
       xfree (wpgmname);
       xfree (wcmdline);
       xfree (cmdline);
-      if (infp)
-        es_fclose (infp);
-      else if (inpipe[1] != INVALID_HANDLE_VALUE)
-        CloseHandle (outpipe[1]);
-      if (inpipe[0] != INVALID_HANDLE_VALUE)
-        CloseHandle (inpipe[0]);
-      if (outfp)
-        es_fclose (outfp);
-      else if (outpipe[0] != INVALID_HANDLE_VALUE)
-        CloseHandle (outpipe[0]);
-      if (outpipe[1] != INVALID_HANDLE_VALUE)
-        CloseHandle (outpipe[1]);
-      if (errfp)
-        es_fclose (errfp);
-      else if (errpipe[0] != INVALID_HANDLE_VALUE)
-        CloseHandle (errpipe[0]);
-      if (errpipe[1] != INVALID_HANDLE_VALUE)
-        CloseHandle (errpipe[1]);
-      return gpg_err_make (errsource, GPG_ERR_GENERAL);
+      return GPG_ERR_GENERAL;
     }
+  if (si.lpAttributeList)
+    DeleteProcThreadAttributeList (si.lpAttributeList);
   xfree (wpgmname);
   xfree (wcmdline);
   xfree (cmdline);
-  cmdline = NULL;
-
-  /* Close the inherited handles to /dev/null.  */
-  for (i=0; i < DIM (nullhd); i++)
-    if (nullhd[i] != INVALID_HANDLE_VALUE)
-      CloseHandle (nullhd[i]);
 
-  /* Close the inherited ends of the pipes.  */
-  if (inpipe[0] != INVALID_HANDLE_VALUE)
-    CloseHandle (inpipe[0]);
-  if (outpipe[1] != INVALID_HANDLE_VALUE)
-    CloseHandle (outpipe[1]);
-  if (errpipe[1] != INVALID_HANDLE_VALUE)
-    CloseHandle (errpipe[1]);
+  /* log_debug ("CreateProcess(detached) ready: hProcess=%p hThread=%p" */
+  /*           " dwProcessID=%d dwThreadId=%d\n", */
+  /*           pi.hProcess, pi.hThread, */
+  /*          (int) pi.dwProcessId, (int) pi.dwThreadId); */
 
-  /* log_debug ("CreateProcess ready: hProcess=%p hThread=%p" */
-  /*            " dwProcessID=%d dwThreadId=%d\n", */
-  /*            pi.hProcess, pi.hThread, */
-  /*            (int) pi.dwProcessId, (int) pi.dwThreadId); */
-  /* log_debug ("                     outfp=%p errfp=%p\n", outfp, errfp); */
+  /* Note: AllowSetForegroundWindow doesn't make sense for background
+     process.  */
 
-  /* Fixme: For unknown reasons AllowSetForegroundWindow returns an
-     invalid argument error if we pass it the correct processID.  As a
-     workaround we use -1 (ASFW_ANY).  */
-  if ((flags & GNUPG_SPAWN_RUN_ASFW))
-    gnupg_allow_set_foregound_window ((pid_t)(-1)/*pi.dwProcessId*/);
-
-  /* Process has been created suspended; resume it now. */
-  ResumeThread (pi.hThread);
   CloseHandle (pi.hThread);
-
-  if (r_infp)
-    *r_infp = infp;
-  if (r_outfp)
-    *r_outfp = outfp;
-  if (r_errfp)
-    *r_errfp = errfp;
-
-  *pid = handle_to_pid (pi.hProcess);
+  CloseHandle (pi.hProcess);
   return 0;
-
 }
 
 
+void
+gnupg_spawn_helper (struct spawn_cb_arg *sca)
+{
+  HANDLE *user_except = sca->arg;
+  sca->inherit_hds = user_except;
+}
 
-/* Simplified version of gnupg_spawn_process.  This function forks and
-   then execs PGMNAME, while connecting INFD to stdin, OUTFD to stdout
-   and ERRFD to stderr (any of them may be -1 to connect them to
-   /dev/null).  The arguments for the process are expected in the NULL
-   terminated array ARGV.  The program name itself should not be
-   included there.  Calling gnupg_wait_process is required.
-
-   Returns 0 on success or an error code. */
-gpg_error_t
-gnupg_spawn_process_fd (const char *pgmname, const char *argv[],
-                        int infd, int outfd, int errfd, pid_t *pid)
+gpg_err_code_t
+gnupg_process_spawn (const char *pgmname, const char *argv[],
+                     unsigned int flags,
+                     void (*spawn_cb) (struct spawn_cb_arg *),
+                     void *spawn_cb_arg,
+                     gnupg_process_t *r_process)
 {
-  gpg_error_t err;
+  gpg_err_code_t ec;
+  gnupg_process_t process;
   SECURITY_ATTRIBUTES sec_attr;
   PROCESS_INFORMATION pi = { NULL, 0, 0, 0 };
-  STARTUPINFOW si;
+  STARTUPINFOEXW si;
+  int cr_flags;
   char *cmdline;
   wchar_t *wcmdline = NULL;
   wchar_t *wpgmname = NULL;
-  int i, rc;
-  HANDLE stdhd[3];
+  int ret;
+  HANDLE hd_in[2];
+  HANDLE hd_out[2];
+  HANDLE hd_err[2];
+  struct spawn_cb_arg sca;
+  int i;
+  BOOL ask_inherit = FALSE;
+
+  check_syscall_func ();
+
+  /* Build the command line.  */
+  ec = build_w32_commandline (pgmname, argv, &cmdline);
+  if (ec)
+    return ec;
+
+  if ((flags & GNUPG_PROCESS_DETACHED))
+    {
+      if ((flags & GNUPG_PROCESS_STDFDS_SETTING))
+        {
+          xfree (cmdline);
+          return GPG_ERR_INV_FLAG;
+        }
+
+      /* In detached case, it must be no R_PROCESS.  */
+      if (r_process)
+        {
+          xfree (cmdline);
+          return GPG_ERR_INV_ARG;
+        }
+
+      return spawn_detached (pgmname, cmdline, spawn_cb, spawn_cb_arg);
+    }
+
+  if (r_process)
+    *r_process = NULL;
+
+  process = xtrymalloc (sizeof (struct gnupg_process));
+  if (process == NULL)
+    {
+      xfree (cmdline);
+      return gpg_err_code_from_syserror ();
+    }
+
+  process->pgmname = pgmname;
+  process->flags = flags;
+
+  if ((flags & GNUPG_PROCESS_STDINOUT_SOCKETPAIR))
+    {
+      xfree (process);
+      xfree (cmdline);
+      return GPG_ERR_NOT_SUPPORTED;
+    }
+
+  if ((flags & GNUPG_PROCESS_STDIN_PIPE))
+    {
+      ec = create_inheritable_pipe (hd_in, INHERIT_READ);
+      if (ec)
+        {
+          xfree (process);
+          xfree (cmdline);
+          return ec;
+        }
+    }
+  else if ((flags & GNUPG_PROCESS_STDIN_KEEP))
+    {
+      hd_in[0] = GetStdHandle (STD_INPUT_HANDLE);
+      hd_in[1] = INVALID_HANDLE_VALUE;
+    }
+  else
+    {
+      hd_in[0] = w32_open_null (0);
+      hd_in[1] = INVALID_HANDLE_VALUE;
+    }
+
+  if ((flags & GNUPG_PROCESS_STDOUT_PIPE))
+    {
+      ec = create_inheritable_pipe (hd_out, INHERIT_WRITE);
+      if (ec)
+        {
+          if (hd_in[0] != INVALID_HANDLE_VALUE)
+            CloseHandle (hd_in[0]);
+          if (hd_in[1] != INVALID_HANDLE_VALUE)
+            CloseHandle (hd_in[1]);
+          xfree (process);
+          xfree (cmdline);
+          return ec;
+        }
+    }
+  else if ((flags & GNUPG_PROCESS_STDOUT_KEEP))
+    {
+      hd_out[0] = INVALID_HANDLE_VALUE;
+      hd_out[1] = GetStdHandle (STD_OUTPUT_HANDLE);
+    }
+  else
+    {
+      hd_out[0] = INVALID_HANDLE_VALUE;
+      hd_out[1] = w32_open_null (1);
+    }
 
-  /* Setup return values.  */
-  *pid = (pid_t)(-1);
+  if ((flags & GNUPG_PROCESS_STDERR_PIPE))
+    {
+      ec = create_inheritable_pipe (hd_err, INHERIT_WRITE);
+      if (ec)
+        {
+          if (hd_in[0] != INVALID_HANDLE_VALUE)
+            CloseHandle (hd_in[0]);
+          if (hd_in[1] != INVALID_HANDLE_VALUE)
+            CloseHandle (hd_in[1]);
+          if (hd_out[0] != INVALID_HANDLE_VALUE)
+            CloseHandle (hd_out[0]);
+          if (hd_out[1] != INVALID_HANDLE_VALUE)
+            CloseHandle (hd_out[1]);
+          xfree (process);
+          xfree (cmdline);
+          return ec;
+        }
+    }
+  else if ((flags & GNUPG_PROCESS_STDERR_KEEP))
+    {
+      hd_err[0] = INVALID_HANDLE_VALUE;
+      hd_err[1] = GetStdHandle (STD_ERROR_HANDLE);
+    }
+  else
+    {
+      hd_err[0] = INVALID_HANDLE_VALUE;
+      hd_err[1] = w32_open_null (1);
+    }
+
+  memset (&si, 0, sizeof si);
+
+  sca.allow_foreground_window = FALSE;
+  sca.hd[0] = hd_in[0];
+  sca.hd[1] = hd_out[1];
+  sca.hd[2] = hd_err[1];
+  sca.inherit_hds = NULL;
+  sca.arg = spawn_cb_arg;
+  if (spawn_cb)
+    (*spawn_cb) (&sca);
+
+  i = 0;
+  if (sca.hd[0] != INVALID_HANDLE_VALUE)
+    i++;
+  if (sca.hd[1] != INVALID_HANDLE_VALUE)
+    i++;
+  if (sca.hd[2] != INVALID_HANDLE_VALUE)
+    i++;
+
+  if (i != 0 || sca.inherit_hds)
+    {
+      SIZE_T attr_list_size = 0;
+      HANDLE hd[16];
+      HANDLE *hd_p = sca.inherit_hds;
+      int j = 0;
+
+      if (sca.hd[0] != INVALID_HANDLE_VALUE)
+        hd[j++] = sca.hd[0];
+      if (sca.hd[1] != INVALID_HANDLE_VALUE)
+        hd[j++] = sca.hd[1];
+      if (sca.hd[1] != INVALID_HANDLE_VALUE)
+        hd[j++] = sca.hd[2];
+      if (hd_p)
+        {
+          while (*hd_p != INVALID_HANDLE_VALUE)
+            if (j < DIM (hd))
+              hd[j++] = *hd_p++;
+            else
+              {
+                log_error ("Too much handles\n");
+                break;
+              }
+        }
+
+      if (j)
+	{
+	  if (check_windows_version ())
+	    {
+	      InitializeProcThreadAttributeList (NULL, 1, 0, &attr_list_size);
+	      si.lpAttributeList = xtrymalloc (attr_list_size);
+	      if (si.lpAttributeList == NULL)
+		{
+		  if ((flags & GNUPG_PROCESS_STDIN_PIPE)
+		      || !(flags & GNUPG_PROCESS_STDIN_KEEP))
+		    CloseHandle (hd_in[0]);
+		  if ((flags & GNUPG_PROCESS_STDIN_PIPE))
+		    CloseHandle (hd_in[1]);
+		  if ((flags & GNUPG_PROCESS_STDOUT_PIPE))
+		    CloseHandle (hd_out[0]);
+		  if ((flags & GNUPG_PROCESS_STDOUT_PIPE)
+		      || !(flags & GNUPG_PROCESS_STDOUT_KEEP))
+		    CloseHandle (hd_out[1]);
+		  if ((flags & GNUPG_PROCESS_STDERR_PIPE))
+		    CloseHandle (hd_err[0]);
+		  if ((flags & GNUPG_PROCESS_STDERR_PIPE)
+		      || !(flags & GNUPG_PROCESS_STDERR_KEEP))
+		    CloseHandle (hd_err[1]);
+		  xfree (process);
+		  xfree (cmdline);
+		  return gpg_err_code_from_syserror ();
+		}
+	      InitializeProcThreadAttributeList (si.lpAttributeList, 1, 0,
+						 &attr_list_size);
+	      UpdateProcThreadAttribute (si.lpAttributeList, 0,
+					 PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
+					 hd, sizeof (HANDLE) * j, NULL, NULL);
+	    }
+	  ask_inherit = TRUE;
+	}
+    }
 
   /* Prepare security attributes.  */
   memset (&sec_attr, 0, sizeof sec_attr );
   sec_attr.nLength = sizeof sec_attr;
   sec_attr.bInheritHandle = FALSE;
 
-  /* Build the command line.  */
-  err = build_w32_commandline (pgmname, argv, &cmdline);
-  if (err)
-    return err;
-
-  memset (&si, 0, sizeof si);
-  si.cb = sizeof (si);
-  si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
-  si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
-  stdhd[0] = infd  == -1? w32_open_null (0) : INVALID_HANDLE_VALUE;
-  stdhd[1] = outfd == -1? w32_open_null (1) : INVALID_HANDLE_VALUE;
-  stdhd[2] = errfd == -1? w32_open_null (1) : INVALID_HANDLE_VALUE;
-  si.hStdInput  = infd  == -1? stdhd[0] : (void*)_get_osfhandle (infd);
-  si.hStdOutput = outfd == -1? stdhd[1] : (void*)_get_osfhandle (outfd);
-  si.hStdError  = errfd == -1? stdhd[2] : (void*)_get_osfhandle (errfd);
-
-/*   log_debug ("CreateProcess, path='%s' cmdline='%s'\n", pgmname, cmdline); */
-  /* Take care: CreateProcessW may modify wpgmname */
+  /* Start the process.  */
+  si.StartupInfo.cb = sizeof (si);
+  si.StartupInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+  si.StartupInfo.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_HIDE;
+  si.StartupInfo.hStdInput  = sca.hd[0];
+  si.StartupInfo.hStdOutput = sca.hd[1];
+  si.StartupInfo.hStdError  = sca.hd[2];
+
+  /* log_debug ("CreateProcess, path='%s' cmdline='%s'\n", pgmname, cmdline); */
+  cr_flags = (CREATE_DEFAULT_ERROR_MODE
+              | GetPriorityClass (GetCurrentProcess ())
+              | CREATE_SUSPENDED);
   if (!(wpgmname = utf8_to_wchar (pgmname)))
-    rc = 0;
+    ret = 0;
   else if (!(wcmdline = utf8_to_wchar (cmdline)))
-    rc = 0;
+    ret = 0;
   else
-    rc = CreateProcessW (wpgmname,      /* Program to start.  */
-                         wcmdline,      /* Command line arguments.  */
-                         &sec_attr,     /* Process security attributes.  */
-                         &sec_attr,     /* Thread security attributes.  */
-                         TRUE,          /* Inherit handles.  */
-                         (CREATE_DEFAULT_ERROR_MODE
-                          | GetPriorityClass (GetCurrentProcess ())
-                          | CREATE_SUSPENDED | DETACHED_PROCESS),
-                         NULL,          /* Environment.  */
-                         NULL,          /* Use current drive/directory.  */
-                         &si,           /* Startup information. */
-                         &pi            /* Returns process information.  */
-                         );
-  if (!rc)
+    ret = CreateProcessW (wpgmname,      /* Program to start.  */
+                          wcmdline,      /* Command line arguments.  */
+                          &sec_attr,     /* Process security attributes.  */
+                          &sec_attr,     /* Thread security attributes.  */
+                          ask_inherit,   /* Inherit handles.  */
+                          cr_flags,      /* Creation flags.  */
+                          NULL,          /* Environment.  */
+                          NULL,          /* Use current drive/directory.  */
+                          (STARTUPINFOW *)&si,           /* Startup information. */
+                          &pi            /* Returns process information.  */
+                          );
+  if (!ret)
     {
       if (!wpgmname || !wcmdline)
         log_error ("CreateProcess failed (utf8_to_wchar): %s\n",
-                   strerror (errno));
+                          strerror (errno));
       else
-        log_error ("CreateProcess failed: %s\n", w32_strerror (-1));
-      err = my_error (GPG_ERR_GENERAL);
+        log_error ("CreateProcess failed: ec=%d\n",
+                          (int)GetLastError ());
+      if ((flags & GNUPG_PROCESS_STDIN_PIPE)
+          || !(flags & GNUPG_PROCESS_STDIN_KEEP))
+        CloseHandle (hd_in[0]);
+      if ((flags & GNUPG_PROCESS_STDIN_PIPE))
+        CloseHandle (hd_in[1]);
+      if ((flags & GNUPG_PROCESS_STDOUT_PIPE))
+        CloseHandle (hd_out[0]);
+      if ((flags & GNUPG_PROCESS_STDOUT_PIPE)
+          || !(flags & GNUPG_PROCESS_STDOUT_KEEP))
+        CloseHandle (hd_out[1]);
+      if ((flags & GNUPG_PROCESS_STDERR_PIPE))
+        CloseHandle (hd_err[0]);
+      if ((flags & GNUPG_PROCESS_STDERR_PIPE)
+          || !(flags & GNUPG_PROCESS_STDERR_KEEP))
+        CloseHandle (hd_err[1]);
+      xfree (wpgmname);
+      xfree (wcmdline);
+      xfree (process);
+      xfree (cmdline);
+      return GPG_ERR_GENERAL;
     }
-  else
-    err = 0;
+
+  if (si.lpAttributeList)
+    DeleteProcThreadAttributeList (si.lpAttributeList);
   xfree (wpgmname);
   xfree (wcmdline);
   xfree (cmdline);
-  for (i=0; i < 3; i++)
-    if (stdhd[i] != INVALID_HANDLE_VALUE)
-      CloseHandle (stdhd[i]);
-  if (err)
-    return err;
 
-/*   log_debug ("CreateProcess ready: hProcess=%p hThread=%p" */
-/*              " dwProcessID=%d dwThreadId=%d\n", */
-/*              pi.hProcess, pi.hThread, */
-/*              (int) pi.dwProcessId, (int) pi.dwThreadId); */
+  if ((flags & GNUPG_PROCESS_STDIN_PIPE)
+      || !(flags & GNUPG_PROCESS_STDIN_KEEP))
+    CloseHandle (hd_in[0]);
+  if ((flags & GNUPG_PROCESS_STDOUT_PIPE)
+      || !(flags & GNUPG_PROCESS_STDOUT_KEEP))
+    CloseHandle (hd_out[1]);
+  if ((flags & GNUPG_PROCESS_STDERR_PIPE)
+      || !(flags & GNUPG_PROCESS_STDERR_KEEP))
+    CloseHandle (hd_err[1]);
+
+  /* log_debug ("CreateProcess ready: hProcess=%p hThread=%p" */
+  /*           " dwProcessID=%d dwThreadId=%d\n", */
+  /*           pi.hProcess, pi.hThread, */
+  /*           (int) pi.dwProcessId, (int) pi.dwThreadId); */
+
+  if (sca.allow_foreground_window)
+    {
+      /* Fixme: For unknown reasons AllowSetForegroundWindow returns
+       * an invalid argument error if we pass it the correct
+       * processID.  As a workaround we use -1 (ASFW_ANY).  */
+      if (!AllowSetForegroundWindow (ASFW_ANY /*pi.dwProcessId*/))
+        log_info ("AllowSetForegroundWindow() failed: ec=%d\n",
+                  (int)GetLastError ());
+    }
 
   /* Process has been created suspended; resume it now. */
+  pre_syscall ();
   ResumeThread (pi.hThread);
   CloseHandle (pi.hThread);
+  post_syscall ();
 
-  *pid = handle_to_pid (pi.hProcess);
-  return 0;
+  process->hProcess = pi.hProcess;
+  process->hd_in = hd_in[1];
+  process->hd_out = hd_out[0];
+  process->hd_err = hd_err[0];
+  process->exitcode = -1;
+  process->terminated = 0;
 
+  if (r_process == NULL)
+    {
+      ec = gnupg_process_wait (process, 1);
+      gnupg_process_release (process);
+      return ec;
+    }
+
+  *r_process = process;
+  return 0;
 }
 
+gpg_err_code_t
+gnupg_process_get_fds (gnupg_process_t process, unsigned int flags,
+                        int *r_fd_in, int *r_fd_out, int *r_fd_err)
+{
+  (void)flags;
+  if (r_fd_in)
+    {
+      *r_fd_in = _open_osfhandle ((intptr_t)process->hd_in, O_APPEND);
+      process->hd_in = INVALID_HANDLE_VALUE;
+    }
+  if (r_fd_out)
+    {
+      *r_fd_out = _open_osfhandle ((intptr_t)process->hd_out, O_RDONLY);
+      process->hd_out = INVALID_HANDLE_VALUE;
+    }
+  if (r_fd_err)
+    {
+      *r_fd_err = _open_osfhandle ((intptr_t)process->hd_err, O_RDONLY);
+      process->hd_err = INVALID_HANDLE_VALUE;
+    }
 
-/* See exechelp.h for a description.  */
-gpg_error_t
-gnupg_wait_process (const char *pgmname, pid_t pid, int hang, int *r_exitcode)
+  return 0;
+}
+
+gpg_err_code_t
+gnupg_process_get_streams (gnupg_process_t process, unsigned int flags,
+                           estream_t *r_fp_in, estream_t *r_fp_out,
+                           estream_t *r_fp_err)
 {
-  return gnupg_wait_processes (&pgmname, &pid, 1, hang, r_exitcode);
+  int nonblock = (flags & GNUPG_PROCESS_STREAM_NONBLOCK)? 1: 0;
+  es_syshd_t syshd;
+
+  syshd.type = ES_SYSHD_HANDLE;
+  if (r_fp_in)
+    {
+      syshd.u.handle = process->hd_in;
+      *r_fp_in = es_sysopen (&syshd, nonblock? "w,nonblock" : "w");
+      process->hd_in = INVALID_HANDLE_VALUE;
+    }
+  if (r_fp_out)
+    {
+      syshd.u.handle = process->hd_out;
+      *r_fp_out = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
+      process->hd_out = INVALID_HANDLE_VALUE;
+    }
+  if (r_fp_err)
+    {
+      syshd.u.handle = process->hd_err;
+      *r_fp_err = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
+      process->hd_err = INVALID_HANDLE_VALUE;
+    }
+  return 0;
 }
 
-/* See exechelp.h for a description.  */
-gpg_error_t
-gnupg_wait_processes (const char **pgmnames, pid_t *pids, size_t count,
-                      int hang, int *r_exitcodes)
+static gpg_err_code_t
+process_kill (gnupg_process_t process, unsigned int exitcode)
 {
   gpg_err_code_t ec = 0;
-  size_t i;
-  HANDLE *procs;
-  int code;
 
-  procs = xtrycalloc (count, sizeof *procs);
-  if (procs == NULL)
-    return my_error_from_syserror ();
+  pre_syscall ();
+  if (TerminateProcess (process->hProcess, exitcode))
+    ec = gpg_err_code_from_syserror ();
+  post_syscall ();
+  return ec;
+}
 
-  for (i = 0; i < count; i++)
+static gpg_err_code_t
+process_vctl (gnupg_process_t process, unsigned int request, va_list arg_ptr)
+{
+  switch (request)
     {
-      if (r_exitcodes)
-        r_exitcodes[i] = -1;
+    case GNUPG_PROCESS_NOP:
+      return 0;
 
-      if (pids[i] == (pid_t)(-1))
-        return my_error (GPG_ERR_INV_VALUE);
+    case GNUPG_PROCESS_GET_PROC_ID:
+      {
+        int *r_id = va_arg (arg_ptr, int *);
 
-      procs[i] = pid_to_handle (pids[i]);
-    }
+        if (r_id == NULL)
+          return GPG_ERR_INV_VALUE;
 
-  /* FIXME: We should do a pth_waitpid here.  However this has not yet
-     been implemented.  A special W32 pth system call would even be
-     better.  */
-  code = WaitForMultipleObjects (count, procs, TRUE, hang? INFINITE : 0);
-  switch (code)
-    {
-    case WAIT_TIMEOUT:
-      ec = GPG_ERR_TIMEOUT;
-      goto leave;
+        *r_id = (int)GetProcessId (process->hProcess);
+        return 0;
+      }
 
-    case WAIT_FAILED:
-      log_error (_("waiting for processes to terminate failed: %s\n"),
-                 w32_strerror (-1));
-      ec = GPG_ERR_GENERAL;
-      goto leave;
+    case GNUPG_PROCESS_GET_EXIT_ID:
+      {
+        int *r_exit_status = va_arg (arg_ptr, int *);
+        unsigned long exit_code;
 
-    case WAIT_OBJECT_0:
-      for (i = 0; i < count; i++)
-        {
-          DWORD exc;
+        *r_exit_status = -1;
 
-          if (! GetExitCodeProcess (procs[i], &exc))
-            {
-              log_error (_("error getting exit code of process %d: %s\n"),
-                         (int) pids[i], w32_strerror (-1) );
-              ec = GPG_ERR_GENERAL;
-            }
-          else if (exc)
-            {
-              if (!r_exitcodes)
-                log_error (_("error running '%s': exit status %d\n"),
-                           pgmnames[i], (int)exc);
-              else
-                r_exitcodes[i] = (int)exc;
-              ec = GPG_ERR_GENERAL;
-            }
-          else
-            {
-              if (r_exitcodes)
-                r_exitcodes[i] = 0;
-            }
-        }
-      break;
+        if (!process->terminated)
+          return GPG_ERR_UNFINISHED;
+
+        if (process->hProcess == INVALID_HANDLE_VALUE)
+          return 0;
+
+        if (GetExitCodeProcess (process->hProcess, &exit_code) == 0)
+          return gpg_err_code_from_syserror ();
+
+        *r_exit_status = (int)exit_code;
+        return 0;
+      }
+
+    case GNUPG_PROCESS_GET_P_HANDLE:
+      {
+        HANDLE *r_hProcess = va_arg (arg_ptr, HANDLE *);
+
+        if (r_hProcess == NULL)
+          return GPG_ERR_INV_VALUE;
+
+        *r_hProcess = process->hProcess;
+        process->hProcess = INVALID_HANDLE_VALUE;
+        return 0;
+      }
+
+    case GNUPG_PROCESS_GET_HANDLES:
+      {
+        HANDLE *r_hd_in = va_arg (arg_ptr, HANDLE *);
+        HANDLE *r_hd_out = va_arg (arg_ptr, HANDLE *);
+        HANDLE *r_hd_err = va_arg (arg_ptr, HANDLE *);
+
+        if (r_hd_in)
+          {
+            *r_hd_in = process->hd_in;
+            process->hd_in = INVALID_HANDLE_VALUE;
+          }
+        if (r_hd_out)
+          {
+            *r_hd_out = process->hd_out;
+            process->hd_out = INVALID_HANDLE_VALUE;
+          }
+        if (r_hd_err)
+          {
+            *r_hd_err = process->hd_err;
+            process->hd_err = INVALID_HANDLE_VALUE;
+          }
+        return 0;
+      }
+
+    case GNUPG_PROCESS_GET_EXIT_CODE:
+      {
+        unsigned long *r_exitcode = va_arg (arg_ptr, unsigned long *);
+
+        if (!process->terminated)
+          return GPG_ERR_UNFINISHED;
+
+        if (process->hProcess == INVALID_HANDLE_VALUE)
+          {
+            *r_exitcode = (unsigned long)-1;
+            return 0;
+          }
+
+        if (GetExitCodeProcess (process->hProcess, r_exitcode) == 0)
+          return gpg_err_code_from_syserror ();
+        return 0;
+      }
+
+    case GNUPG_PROCESS_KILL_WITH_EC:
+      {
+        unsigned int exitcode = va_arg (arg_ptr, unsigned int);
+
+        if (process->terminated)
+          return 0;
+
+        if (process->hProcess == INVALID_HANDLE_VALUE)
+          return 0;
+
+        return process_kill (process, exitcode);
+      }
 
     default:
-      log_error ("WaitForMultipleObjects returned unexpected "
-                 "code %d\n", code);
-      ec = GPG_ERR_GENERAL;
       break;
     }
 
- leave:
-  return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, ec);
+  return GPG_ERR_UNKNOWN_COMMAND;
 }
 
-
-
-void
-gnupg_release_process (pid_t pid)
+gpg_err_code_t
+gnupg_process_ctl (gnupg_process_t process, unsigned int request, ...)
 {
-  if (pid != (pid_t)INVALID_HANDLE_VALUE)
-    {
-      HANDLE process = (HANDLE)pid;
+  va_list arg_ptr;
+  gpg_err_code_t ec;
 
-      CloseHandle (process);
-    }
+  va_start (arg_ptr, request);
+  ec = process_vctl (process, request, arg_ptr);
+  va_end (arg_ptr);
+  return ec;
 }
 
-
-/* Spawn a new process and immediately detach from it.  The name of
-   the program to exec is PGMNAME and its arguments are in ARGV (the
-   programname is automatically passed as first argument).
-   Environment strings in ENVP are set.  An error is returned if
-   pgmname is not executable; to make this work it is necessary to
-   provide an absolute file name.  All standard file descriptors are
-   connected to /dev/null. */
-gpg_error_t
-gnupg_spawn_process_detached (const char *pgmname, const char *argv[],
-                              const char *envp[] )
+gpg_err_code_t
+gnupg_process_wait (gnupg_process_t process, int hang)
 {
-  gpg_error_t err;
-  SECURITY_ATTRIBUTES sec_attr;
-  PROCESS_INFORMATION pi =
-    {
-      NULL,      /* Returns process handle.  */
-      0,         /* Returns primary thread handle.  */
-      0,         /* Returns pid.  */
-      0          /* Returns tid.  */
-    };
-  STARTUPINFOW si;
-  int cr_flags;
-  char *cmdline;
-  wchar_t *wcmdline = NULL;
-  wchar_t *wpgmname = NULL;
-  BOOL in_job = FALSE;
   gpg_err_code_t ec;
-  int rc;
-  int jobdebug;
+  int code;
 
-  /* We don't use ENVP.  */
-  (void)envp;
+  if (process->hProcess == INVALID_HANDLE_VALUE)
+    return 0;
 
-  cmdline = getenv ("GNUPG_EXEC_DEBUG_FLAGS");
-  jobdebug = (cmdline && (atoi (cmdline) & 1));
+  pre_syscall ();
+  code = WaitForSingleObject (process->hProcess, hang? INFINITE : 0);
+  post_syscall ();
 
-  if ((ec = gnupg_access (pgmname, X_OK)))
-    return gpg_err_make (default_errsource, ec);
+  switch (code)
+    {
+    case WAIT_TIMEOUT:
+      ec = GPG_ERR_TIMEOUT; /* Still running.  */
+      break;
 
-  /* Prepare security attributes.  */
-  memset (&sec_attr, 0, sizeof sec_attr );
-  sec_attr.nLength = sizeof sec_attr;
-  sec_attr.bInheritHandle = FALSE;
+    case WAIT_FAILED:
+      log_error (_("waiting for process to terminate failed: ec=%d\n"),
+                 (int)GetLastError ());
+      ec = GPG_ERR_GENERAL;
+      break;
 
-  /* Build the command line.  */
-  err = build_w32_commandline (pgmname, argv, &cmdline);
-  if (err)
-    return err;
+    case WAIT_OBJECT_0:
+      process->terminated = 1;
+      ec = 0;
+      break;
 
-  /* Start the process.  */
-  memset (&si, 0, sizeof si);
-  si.cb = sizeof (si);
-  si.dwFlags = STARTF_USESHOWWINDOW;
-  si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
+    default:
+      log_debug ("WaitForSingleObject returned unexpected code %d\n", code);
+      ec = GPG_ERR_GENERAL;
+      break;
+    }
 
-  cr_flags = (CREATE_DEFAULT_ERROR_MODE
-              | GetPriorityClass (GetCurrentProcess ())
-              | CREATE_NEW_PROCESS_GROUP
-              | DETACHED_PROCESS);
+  return ec;
+}
 
-  /* Check if we were spawned as part of a Job.
-   * In a job we need to add CREATE_BREAKAWAY_FROM_JOB
-   * to the cr_flags, otherwise our child processes
-   * are killed when we terminate. */
-  if (!IsProcessInJob (GetCurrentProcess(), NULL, &in_job))
-    {
-      log_error ("IsProcessInJob() failed: %s\n", w32_strerror (-1));
-      in_job = FALSE;
-    }
+gpg_err_code_t
+gnupg_process_terminate (gnupg_process_t process)
+{
+  return process_kill (process, 1);
+}
 
-  if (in_job)
-    {
-      /* Only try to break away from job if it is allowed, otherwise
-       * CreateProcess() would fail with an "Access is denied" error. */
-      JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
-      if (!QueryInformationJobObject (NULL, JobObjectExtendedLimitInformation,
-                                      &info, sizeof info, NULL))
-        {
-          log_error ("QueryInformationJobObject() failed: %s\n",
-                     w32_strerror (-1));
-        }
-      else if ((info.BasicLimitInformation.LimitFlags &
-                JOB_OBJECT_LIMIT_BREAKAWAY_OK))
-        {
-          if (jobdebug)
-            log_debug ("Using CREATE_BREAKAWAY_FROM_JOB flag\n");
-          cr_flags |= CREATE_BREAKAWAY_FROM_JOB;
-        }
-      else if ((info.BasicLimitInformation.LimitFlags &
-                JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK))
-        {
-          /* The child process should automatically detach from the job. */
-          if (jobdebug)
-            log_debug ("Not using CREATE_BREAKAWAY_FROM_JOB flag; "
-                       "JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK is set\n");
-        }
-      else
-        {
-          /* It seems that the child process must remain in the job.
-           * This is not necessarily an error, although it can cause premature
-           * termination of the child process when the job is closed. */
-          if (jobdebug)
-            log_debug ("Not using CREATE_BREAKAWAY_FROM_JOB flag\n");
-        }
-    }
-  else
-    {
-      if (jobdebug)
-        log_debug ("Process is not in a Job\n");
-    }
+void
+gnupg_process_release (gnupg_process_t process)
+{
+  if (!process)
+    return;
 
-  /*   log_debug ("CreateProcess(detached), path='%s' cmdline='%s'\n", */
-  /*              pgmname, cmdline); */
-  /* Take care: CreateProcessW may modify wpgmname */
-  if (!(wpgmname = utf8_to_wchar (pgmname)))
-    rc = 0;
-  else if (!(wcmdline = utf8_to_wchar (cmdline)))
-    rc = 0;
-  else
-    rc = CreateProcessW (wpgmname,      /* Program to start.  */
-                         wcmdline,      /* Command line arguments.  */
-                         &sec_attr,     /* Process security attributes.  */
-                         &sec_attr,     /* Thread security attributes.  */
-                         FALSE,         /* Inherit handles.  */
-                         cr_flags,      /* Creation flags.  */
-                         NULL,          /* Environment.  */
-                         NULL,          /* Use current drive/directory.  */
-                         &si,           /* Startup information. */
-                         &pi            /* Returns process information.  */
-                         );
-  if (!rc)
+  if (process->terminated)
     {
-      if (!wpgmname || !wcmdline)
-        log_error ("CreateProcess failed (utf8_to_wchar): %s\n",
-                   strerror (errno));
-      else
-        log_error ("CreateProcess(detached) failed: %s\n", w32_strerror (-1));
-      xfree (wpgmname);
-      xfree (wcmdline);
-      xfree (cmdline);
-      return my_error (GPG_ERR_GENERAL);
+      gnupg_process_terminate (process);
+      gnupg_process_wait (process, 1);
     }
-  xfree (wpgmname);
-  xfree (wcmdline);
-  xfree (cmdline);
-  cmdline = NULL;
-
-/*   log_debug ("CreateProcess(detached) ready: hProcess=%p hThread=%p" */
-/*              " dwProcessID=%d dwThreadId=%d\n", */
-/*              pi.hProcess, pi.hThread, */
-/*              (int) pi.dwProcessId, (int) pi.dwThreadId); */
 
-  CloseHandle (pi.hThread);
-  CloseHandle (pi.hProcess);
-
-  return 0;
+  xfree (process);
 }
 
-
-/* Kill a process; that is send an appropriate signal to the process.
-   gnupg_wait_process must be called to actually remove the process
-   from the system.  An invalid PID is ignored.  */
-void
-gnupg_kill_process (pid_t pid)
+gpg_err_code_t
+gnupg_process_wait_list (gnupg_process_t *process_list, int count, int hang)
 {
-  if (pid != (pid_t) INVALID_HANDLE_VALUE)
+  gpg_err_code_t ec = 0;
+  int i;
+
+  for (i = 0; i < count; i++)
     {
-      HANDLE process = (HANDLE) pid;
+      if (process_list[i]->terminated)
+        continue;
 
-      /* Arbitrary error code.  */
-      TerminateProcess (process, 1);
+      ec = gnupg_process_wait (process_list[i], hang);
+      if (ec)
+        break;
     }
+
+  return ec;
 }