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]>

5 files changed, 174 insertions, 167 deletions

diff --git a/tests/gpgscm/ffi.c b/tests/gpgscm/ffi.c
index ce18e0794..b46d5cb61 100644
--- a/tests/gpgscm/ffi.c
+++ b/tests/gpgscm/ffi.c
@@ -42,6 +42,9 @@
 #endif
 
 #include "../../common/util.h"
+#ifdef HAVE_W32_SYSTEM
+#define NEED_STRUCT_SPAWN_CB_ARG
+#endif
 #include "../../common/exechelp.h"
 #include "../../common/sysutils.h"
 
@@ -753,25 +756,86 @@ do_es_write (scheme *sc, pointer args)
 }
 
 
-
 /* Process handling.  */
 
+struct proc_object_box
+{
+  gnupg_process_t proc;
+};
+
+static void
+proc_object_finalize (scheme *sc, void *data)
+{
+  struct proc_object_box *box = data;
+  (void) sc;
+
+  if (!box->proc)
+    gnupg_process_release (box->proc);
+  xfree (box);
+}
+
+static void
+proc_object_to_string (scheme *sc, char *out, size_t size, void *data)
+{
+  struct proc_object_box *box = data;
+  (void) sc;
+
+  snprintf (out, size, "#proc %p", box->proc);
+}
+
+static struct foreign_object_vtable proc_object_vtable =
+  {
+    proc_object_finalize,
+    proc_object_to_string,
+  };
+
 static pointer
-do_spawn_process (scheme *sc, pointer args)
+proc_wrap (scheme *sc, gnupg_process_t proc)
+{
+  struct proc_object_box *box = xmalloc (sizeof *box);
+  if (box == NULL)
+    return sc->NIL;
+
+  box->proc = proc;
+  return sc->vptr->mk_foreign_object (sc, &proc_object_vtable, box);
+}
+
+static struct proc_object_box *
+proc_unwrap (scheme *sc, pointer object)
+{
+  (void) sc;
+
+  if (! is_foreign_object (object))
+    return NULL;
+
+  if (sc->vptr->get_foreign_object_vtable (object) != &proc_object_vtable)
+    return NULL;
+
+  return sc->vptr->get_foreign_object_data (object);
+}
+
+#define CONVERSION_proc(SC, X)	proc_unwrap (SC, X)
+#define IS_A_proc(SC, X)		proc_unwrap (SC, X)
+
+
+static pointer
+do_process_spawn (scheme *sc, pointer args)
 {
   FFI_PROLOG ();
   pointer arguments;
   char **argv;
   size_t len;
   unsigned int flags;
-
+  gnupg_process_t proc = NULL;
   estream_t infp;
   estream_t outfp;
   estream_t errfp;
-  pid_t pid;
 
   FFI_ARG_OR_RETURN (sc, pointer, arguments, list, args);
   FFI_ARG_OR_RETURN (sc, unsigned int, flags, number, args);
+  flags |= (GNUPG_PROCESS_STDIN_PIPE
+            | GNUPG_PROCESS_STDOUT_PIPE
+            | GNUPG_PROCESS_STDERR_PIPE);
   FFI_ARGS_DONE_OR_RETURN (sc, args);
 
   err = ffi_list2argv (sc, arguments, &argv, &len);
@@ -791,38 +855,55 @@ do_spawn_process (scheme *sc, pointer args)
       fprintf (stderr, "\n");
     }
 
-  err = gnupg_spawn_process (argv[0], (const char **) &argv[1],
-                             NULL,
-                             flags,
-                             &infp, &outfp, &errfp, &pid);
+  err = gnupg_process_spawn (argv[0], (const char **) &argv[1],
+                             flags, NULL, NULL, &proc);
+  err = gnupg_process_get_streams (proc, 0, &infp, &outfp, &errfp);
   xfree (argv);
-#define IMC(A, B)                                                       \
-  _cons (sc, sc->vptr->mk_integer (sc, (unsigned long) (A)), (B), 1)
+#define IMP(A, B)                                                       \
+  _cons (sc, proc_wrap (sc, (A)), (B), 1)
 #define IMS(A, B)                                                       \
   _cons (sc, es_wrap (sc, (A)), (B), 1)
   FFI_RETURN_POINTER (sc, IMS (infp,
                               IMS (outfp,
                                    IMS (errfp,
-                                        IMC (pid, sc->NIL)))));
+                                        IMP (proc, sc->NIL)))));
 #undef IMS
 #undef IMC
 }
 
+static void
+setup_std_fds (struct spawn_cb_arg *sca)
+{
+  int *std_fds = sca->arg;
+
+#ifdef HAVE_W32_SYSTEM
+  sca->hd[0] = std_fds[0] == -1?
+    INVALID_HANDLE_VALUE : (HANDLE)_get_osfhandle (std_fds[0]);
+  sca->hd[1] = std_fds[1] == -1?
+    INVALID_HANDLE_VALUE : (HANDLE)_get_osfhandle (std_fds[1]);
+  sca->hd[2] = std_fds[2] == -1?
+    INVALID_HANDLE_VALUE : (HANDLE)_get_osfhandle (std_fds[2]);
+#else
+  sca->fds[0] = std_fds[0];
+  sca->fds[1] = std_fds[1];
+  sca->fds[2] = std_fds[2];
+#endif
+}
+
 static pointer
-do_spawn_process_fd (scheme *sc, pointer args)
+do_process_spawn_fd (scheme *sc, pointer args)
 {
   FFI_PROLOG ();
   pointer arguments;
   char **argv;
   size_t len;
-  int infd, outfd, errfd;
-
-  pid_t pid;
+  int std_fds[3];
+  gnupg_process_t proc = NULL;
 
   FFI_ARG_OR_RETURN (sc, pointer, arguments, list, args);
-  FFI_ARG_OR_RETURN (sc, int, infd, number, args);
-  FFI_ARG_OR_RETURN (sc, int, outfd, number, args);
-  FFI_ARG_OR_RETURN (sc, int, errfd, number, args);
+  FFI_ARG_OR_RETURN (sc, int, std_fds[0], number, args);
+  FFI_ARG_OR_RETURN (sc, int, std_fds[1], number, args);
+  FFI_ARG_OR_RETURN (sc, int, std_fds[2], number, args);
   FFI_ARGS_DONE_OR_RETURN (sc, args);
 
   err = ffi_list2argv (sc, arguments, &argv, &len);
@@ -839,107 +920,35 @@ do_spawn_process_fd (scheme *sc, pointer args)
       fprintf (stderr, "Executing:");
       for (p = argv; *p; p++)
         fprintf (stderr, " '%s'", *p);
-      fprintf (stderr, "\n");
+      fprintf (stderr, " (%d %d %d)\n", std_fds[0], std_fds[1], std_fds[2]);
     }
 
-  err = gnupg_spawn_process_fd (argv[0], (const char **) &argv[1],
-                                infd, outfd, errfd, &pid);
+  err = gnupg_process_spawn (argv[0], (const char **) &argv[1],
+                             0, setup_std_fds, std_fds, &proc);
   xfree (argv);
-  FFI_RETURN_INT (sc, pid);
+  FFI_RETURN_POINTER (sc, proc_wrap (sc, proc));
 }
 
 static pointer
-do_wait_process (scheme *sc, pointer args)
+do_process_wait (scheme *sc, pointer args)
 {
   FFI_PROLOG ();
-  const char *name;
-  pid_t pid;
+  struct proc_object_box *box;
   int hang;
+  int retcode = -1;
 
-  int retcode;
-
-  FFI_ARG_OR_RETURN (sc, const char *, name, string, args);
-  FFI_ARG_OR_RETURN (sc, pid_t, pid, number, args);
+  FFI_ARG_OR_RETURN (sc, struct proc_object_box *, box, proc, args);
   FFI_ARG_OR_RETURN (sc, int, hang, bool, args);
   FFI_ARGS_DONE_OR_RETURN (sc, args);
-  err = gnupg_wait_process (name, pid, hang, &retcode);
-  if (err == GPG_ERR_GENERAL)
-    err = 0;	/* Let the return code speak for itself.  */
-
-  FFI_RETURN_INT (sc, retcode);
-}
-
-
-static pointer
-do_wait_processes (scheme *sc, pointer args)
-{
-  FFI_PROLOG ();
-  pointer list_names;
-  char **names;
-  pointer list_pids;
-  size_t i, count;
-  pid_t *pids;
-  int hang;
-  int *retcodes;
-  pointer retcodes_list = sc->NIL;
-
-  FFI_ARG_OR_RETURN (sc, pointer, list_names, list, args);
-  FFI_ARG_OR_RETURN (sc, pointer, list_pids, list, args);
-  FFI_ARG_OR_RETURN (sc, int, hang, bool, args);
-  FFI_ARGS_DONE_OR_RETURN (sc, args);
-
-  if (sc->vptr->list_length (sc, list_names)
-      != sc->vptr->list_length (sc, list_pids))
-    return
-      sc->vptr->mk_string (sc, "length of first two arguments must match");
-
-  err = ffi_list2argv (sc, list_names, &names, &count);
-  if (err == gpg_error (GPG_ERR_INV_VALUE))
-    return ffi_sprintf (sc, "%lu%s element of first argument is "
-                        "neither string nor symbol",
-                        (unsigned long) count,
-                        ordinal_suffix ((int) count));
-  if (err)
-    FFI_RETURN_ERR (sc, err);
-
-  err = ffi_list2intv (sc, list_pids, (int **) &pids, &count);
-  if (err == gpg_error (GPG_ERR_INV_VALUE))
-    return ffi_sprintf (sc, "%lu%s element of second argument is "
-                        "not a number",
-                        (unsigned long) count,
-                        ordinal_suffix ((int) count));
-  if (err)
-    FFI_RETURN_ERR (sc, err);
-
-  retcodes = xtrycalloc (sizeof *retcodes, count);
-  if (retcodes == NULL)
-    {
-      xfree (names);
-      xfree (pids);
-      FFI_RETURN_ERR (sc, gpg_error_from_syserror ());
-    }
-
-  err = gnupg_wait_processes ((const char **) names, pids, count, hang,
-                              retcodes);
-  if (err == GPG_ERR_GENERAL)
-    err = 0;	/* Let the return codes speak.  */
+  err = gnupg_process_wait (box->proc, hang);
+  if (!err)
+    err = gnupg_process_ctl (box->proc, GNUPG_PROCESS_GET_EXIT_ID, &retcode);
   if (err == GPG_ERR_TIMEOUT)
-    err = 0;	/* We may have got some results.  */
-
-  for (i = 0; i < count; i++)
-    retcodes_list =
-      (sc->vptr->cons) (sc,
-                        sc->vptr->mk_integer (sc,
-                                              (long) retcodes[count-1-i]),
-                        retcodes_list);
+    err = 0;
 
-  xfree (names);
-  xfree (pids);
-  xfree (retcodes);
-  FFI_RETURN_POINTER (sc, retcodes_list);
+  FFI_RETURN_INT (sc, retcode);
 }
 
-
 static pointer
 do_pipe (scheme *sc, pointer args)
 {
@@ -1398,13 +1407,12 @@ ffi_init (scheme *sc, const char *argv0, const char *scriptname,
   ffi_define_function (sc, make_random_string);
 
   /* Process management.  */
-  ffi_define_function (sc, spawn_process);
-  ffi_define_function (sc, spawn_process_fd);
-  ffi_define_function (sc, wait_process);
-  ffi_define_function (sc, wait_processes);
   ffi_define_function (sc, pipe);
   ffi_define_function (sc, inbound_pipe);
   ffi_define_function (sc, outbound_pipe);
+  ffi_define_function (sc, process_spawn);
+  ffi_define_function (sc, process_spawn_fd);
+  ffi_define_function (sc, process_wait);
 
   /* estream functions.  */
   ffi_define_function_name (sc, "es-fclose", es_fclose);
diff --git a/tests/gpgscm/t-child.scm b/tests/gpgscm/t-child.scm
index fd1dcc3fe..461413b9c 100644
--- a/tests/gpgscm/t-child.scm
+++ b/tests/gpgscm/t-child.scm
@@ -69,37 +69,36 @@
   (assert (string=? "" (:stderr r))))
 
 (define (spawn what)
-  (spawn-process-fd what CLOSED_FD STDOUT_FILENO STDERR_FILENO))
+  (process-spawn-fd what CLOSED_FD STDOUT_FILENO STDERR_FILENO))
 
-(let ((pid0 (spawn `(,(qualify "t-child") "return0")))
-      (pid1 (spawn `(,(qualify "t-child") "return0"))))
-  (assert (equal? '(0 0)
-		  (wait-processes '("child0" "child1") (list pid0 pid1) #t))))
+(let ((proc0 (spawn `(,(qualify "t-child") "return0")))
+      (proc1 (spawn `(,(qualify "t-child") "return0"))))
+  (assert (= (process-wait proc0 #t) 0))
+  (assert (= (process-wait proc1 #t) 0)))
 
-(let ((pid0 (spawn `(,(qualify "t-child") "return1")))
-      (pid1 (spawn `(,(qualify "t-child") "return0"))))
-  (assert (equal? '(1 0)
-		  (wait-processes '("child0" "child1") (list pid0 pid1) #t))))
+(let ((proc0 (spawn `(,(qualify "t-child") "return1")))
+      (proc1 (spawn `(,(qualify "t-child") "return0"))))
+  (assert (= (process-wait proc0 #t) 1))
+  (assert (= (process-wait proc1 #t) 0)))
 
-(let ((pid0 (spawn `(,(qualify "t-child") "return0")))
-      (pid1 (spawn `(,(qualify "t-child") "return77")))
-      (pid2 (spawn `(,(qualify "t-child") "return1"))))
-  (assert (equal? '(0 77 1)
-		  (wait-processes '("child0" "child1" "child2")
-				  (list pid0 pid1 pid2) #t))))
+(let ((proc0 (spawn `(,(qualify "t-child") "return0")))
+      (proc1 (spawn `(,(qualify "t-child") "return77")))
+      (proc2 (spawn `(,(qualify "t-child") "return1"))))
+  (assert (= (process-wait proc0 #t) 0))
+  (assert (= (process-wait proc1 #t) 77))
+  (assert (= (process-wait proc2 #t) 1)))
 
 (let* ((p (pipe))
-       (pid0 (spawn-process-fd
+       (proc0 (process-spawn-fd
 	       `(,(qualify "t-child") "hello_stdout")
 	       CLOSED_FD (:write-end p) STDERR_FILENO))
        (_ (close (:write-end p)))
-       (pid1 (spawn-process-fd
+       (proc1 (process-spawn-fd
 	       `(,(qualify "t-child") "cat")
 	       (:read-end p) STDOUT_FILENO STDERR_FILENO)))
   (close (:read-end p))
-  (assert
-   (equal? '(0 0)
-	   (wait-processes '("child0" "child1") (list pid0 pid1) #t))))
+  (assert (= (process-wait proc0 #t) 0))
+  (assert (= (process-wait proc1 #t) 0)))
 (echo " world.")
 
 (tr:do
diff --git a/tests/gpgscm/tests.scm b/tests/gpgscm/tests.scm
index db1025bbb..6a11e55f1 100644
--- a/tests/gpgscm/tests.scm
+++ b/tests/gpgscm/tests.scm
@@ -81,7 +81,7 @@
 ;; Process management.
 (define CLOSED_FD -1)
 (define (call-with-fds what infd outfd errfd)
-  (wait-process (stringify what) (spawn-process-fd what infd outfd errfd) #t))
+  (process-wait (process-spawn-fd what infd outfd errfd) #t))
 (define (call what)
   (call-with-fds what
 		 CLOSED_FD
@@ -92,19 +92,19 @@
 (define :stdin car)
 (define :stdout cadr)
 (define :stderr caddr)
-(define :pid cadddr)
+(define :proc cadddr)
 
 (define (call-with-io what in)
-  (let ((h (spawn-process what 0)))
+  (let ((h (process-spawn what 0)))
     (es-write (:stdin h) in)
     (es-fclose (:stdin h))
     (let* ((out (es-read-all (:stdout h)))
 	   (err (es-read-all (:stderr h)))
-	   (result (wait-process (car what) (:pid h) #t)))
+	   (result (process-wait (:proc h) #t)))
       (es-fclose (:stdout h))
       (es-fclose (:stderr h))
       (if (> (*verbose*) 2)
-	  (info "Child" (:pid h) "returned:"
+	  (info "Child" (:proc h) "returned:"
 		`((command ,(stringify what))
 		  (status ,result)
 		  (stdout ,out)
@@ -351,12 +351,8 @@
       (define (dump)
 	(write (list procs source sink producer))
 	(newline))
-      (define (add-proc command pid)
-	(new (cons (list command pid) procs) source sink producer))
-      (define (commands)
-	(map car procs))
-      (define (pids)
-	(map cadr procs))
+      (define (add-proc proc)
+	(new (cons proc procs) source sink producer))
       (define (set-source source')
 	(new procs source' sink producer))
       (define (set-sink sink')
@@ -367,17 +363,19 @@
 	(new procs source sink producer'))))))
 
 
+(define (process-wait-list procs hang)
+  (map (lambda (p) (process-wait p hang)) procs))
+
 (define (pipe:do . commands)
   (let loop ((M (pipeM::new '() CLOSED_FD CLOSED_FD #f)) (cmds commands))
     (if (null? cmds)
 	(begin
 	  (if M::producer (M::producer))
 	  (if (not (null? M::procs))
-	      (let* ((retcodes (wait-processes (map stringify (M::commands))
-					       (M::pids) #t))
-		     (results (map (lambda (p r) (append p (list r)))
+	      (let* ((retcodes (process-wait-list M::procs #t))
+		     (results (map (lambda (p r) (cons p r))
 				   M::procs retcodes))
-		     (failed (filter (lambda (x) (not (= 0 (caddr x))))
+		     (failed (filter (lambda (x) (not (= 0 (cdr x))))
 				     results)))
 		(if (not (null? failed))
 		    (throw failed))))) ; xxx nicer reporting
@@ -408,11 +406,11 @@
 (define (pipe:spawn command)
   (lambda (M)
     (define (do-spawn M new-source)
-      (let ((pid (spawn-process-fd command M::source M::sink
-				   (if (> (*verbose*) 0)
-				       STDERR_FILENO CLOSED_FD)))
+      (let ((proc (process-spawn-fd command M::source M::sink
+				    (if (> (*verbose*) 0)
+				        STDERR_FILENO CLOSED_FD)))
 	    (M' (M::set-source new-source)))
-	(M'::add-proc command pid)))
+	(M'::add-proc proc)))
     (if (= CLOSED_FD M::sink)
 	(let* ((p (pipe))
 	       (M' (do-spawn (M::set-sink (:write-end p)) (:read-end p))))
@@ -568,8 +566,8 @@
 	      (assert (= (length enqueued) (- i 1)))
 	      test)))))
 
-      (define (pid->test pid)
-	(let ((t (filter (lambda (x) (= pid x::pid)) procs)))
+      (define (proc->test proc)
+	(let ((t (filter (lambda (x) (eq? proc x::proc)) procs)))
 	  (if (null? t) #f (car t))))
       (define (wait)
 	(if (null? enqueued)
@@ -587,7 +585,7 @@
 	  (if (null? unfinished)
 	      (current-environment)
 	      (let ((names (map (lambda (t) t::name) unfinished))
-		    (pids (map (lambda (t) t::pid) unfinished))
+		    (procs (map (lambda (t) t::proc) unfinished))
 		    (any #f))
 		(for-each
 		 (lambda (test retcode)
@@ -597,8 +595,8 @@
 			   (test::report)
 			   (sem::release!)
 			   (set! any #t)))
-		 (map pid->test pids)
-		 (wait-processes (map stringify names) pids hang))
+		 (map proc->test procs)
+		 (process-wait-list procs hang))
 
 		;; If some processes finished, try to start new ones.
 		(let loop ()
@@ -682,7 +680,7 @@
    (define (scm setup variant name path . args)
      ;; Start the process.
      (define (spawn-scm args' in out err)
-       (spawn-process-fd `(,*argv0* ,@(verbosity (*verbose*))
+       (process-spawn-fd `(,*argv0* ,@(verbosity (*verbose*))
 				    ,(locate-test (test-name path))
 				    ,@(if setup (force setup) '())
 				    ,@args' ,@args) in out err))
@@ -691,12 +689,12 @@
    (define (binary setup name path . args)
      ;; Start the process.
      (define (spawn-binary args' in out err)
-       (spawn-process-fd `(,(test-name path)
+       (process-spawn-fd `(,(test-name path)
 			   ,@(if setup (force setup) '()) ,@args' ,@args)
 			 in out err))
      (new #f name #f spawn-binary #f #f CLOSED_FD (expect-failure? name)))
 
-   (define (new variant name directory spawn pid retcode logfd expect-failure)
+   (define (new variant name directory spawn proc retcode logfd expect-failure)
      (package
 
       ;; XXX: OO glue.
@@ -721,7 +719,7 @@
 
       ;; Has the test been started yet?
       (define (started?)
-	(number? pid))
+	proc)
 
       (define (open-log-file)
 	(unless log-file-name
@@ -738,26 +736,26 @@
 	(letfd ((log (open-log-file)))
 	  (with-working-directory directory
 	    (let* ((p (inbound-pipe))
-		   (pid' (spawn args 0 (:write-end p) (:write-end p))))
+		   (proc' (spawn args 0 (:write-end p) (:write-end p))))
 	      (close (:write-end p))
 	      (splice (:read-end p) STDERR_FILENO log)
 	      (close (:read-end p))
-	      (set! pid pid')
-	      (set! retcode (wait-process name pid' #t)))))
+	      (set! proc proc')
+	      (set! retcode (process-wait proc' #t)))))
 	(report)
 	(current-environment))
       (define (run-sync-quiet . args)
 	(set-start-time!)
 	(with-working-directory directory
-	  (set! pid (spawn args CLOSED_FD CLOSED_FD CLOSED_FD)))
-	(set! retcode (wait-process name pid #t))
+	  (set! proc (spawn args CLOSED_FD CLOSED_FD CLOSED_FD)))
+	(set! retcode (process-wait proc #t))
 	(set-end-time!)
 	(current-environment))
       (define (run-async . args)
 	(set-start-time!)
 	(let ((log (open-log-file)))
 	  (with-working-directory directory
-	    (set! pid (spawn args CLOSED_FD log log)))
+	    (set! proc (spawn args CLOSED_FD log log)))
 	  (set! logfd log))
 	(current-environment))
       (define (status)
diff --git a/tests/openpgp/defs.scm b/tests/openpgp/defs.scm
index bf3714f50..1ac25bf65 100644
--- a/tests/openpgp/defs.scm
+++ b/tests/openpgp/defs.scm
@@ -268,13 +268,14 @@
 (define (gpg-pipe args0 args1 errfd)
   (lambda (source sink)
     (let* ((p (pipe))
-	   (task0 (spawn-process-fd `(,@GPG ,@args0)
+	   (task0 (process-spawn-fd `(,@GPG ,@args0)
 		   source (:write-end p) errfd))
 	   (_ (close (:write-end p)))
-	   (task1 (spawn-process-fd `(,@GPG ,@args1)
+	   (task1 (process-spawn-fd `(,@GPG ,@args1)
 		   (:read-end p) sink errfd)))
       (close (:read-end p))
-      (wait-processes (list GPG GPG) (list task0 task1) #t))))
+      (process-wait task0 #t)
+      (process-wait task1 #t))))
 
 (setenv "GPG_AGENT_INFO" "" #t)
 (setenv "GNUPGHOME" (getcwd) #t)
diff --git a/tests/tpm2dtests/defs.scm b/tests/tpm2dtests/defs.scm
index 0fef71806..a913818f5 100644
--- a/tests/tpm2dtests/defs.scm
+++ b/tests/tpm2dtests/defs.scm
@@ -217,13 +217,14 @@
 (define (gpg-pipe args0 args1 errfd)
   (lambda (source sink)
     (let* ((p (pipe))
-	   (task0 (spawn-process-fd `(,@GPG ,@args0)
+	   (task0 (process-spawn-fd `(,@GPG ,@args0)
 		   source (:write-end p) errfd))
 	   (_ (close (:write-end p)))
-	   (task1 (spawn-process-fd `(,@GPG ,@args1)
+	   (task1 (process-spawn-fd `(,@GPG ,@args1)
 		   (:read-end p) sink errfd)))
       (close (:read-end p))
-      (wait-processes (list GPG GPG) (list task0 task1) #t))))
+      (process-wait task0 #t)
+      (process-wait task1 #t))))
 
 ;;
 ;; Do we have a software tpm