tests: Do not autostart gpg-agents on teardown.
[gnupg.git] / common / exechelp-w32.c
1 /* exechelp-w32.c - Fork and exec helpers for W32.
2  * Copyright (C) 2004, 2007, 2008, 2009,
3  *               2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * This file is free software; you can redistribute it and/or modify
8  * it under the terms of either
9  *
10  *   - the GNU Lesser General Public License as published by the Free
11  *     Software Foundation; either version 3 of the License, or (at
12  *     your option) any later version.
13  *
14  * or
15  *
16  *   - the GNU General Public License as published by the Free
17  *     Software Foundation; either version 2 of the License, or (at
18  *     your option) any later version.
19  *
20  * or both in parallel, as here.
21  *
22  * This file is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, see <http://www.gnu.org/licenses/>.
29  */
30
31 #include <config.h>
32
33 #if !defined(HAVE_W32_SYSTEM) || defined (HAVE_W32CE_SYSTEM)
34 #error This code is only used on W32.
35 #endif
36
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <errno.h>
41 #include <assert.h>
42 #ifdef HAVE_SIGNAL_H
43 # include <signal.h>
44 #endif
45 #include <unistd.h>
46 #include <fcntl.h>
47
48 #ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth.  */
49 #undef HAVE_NPTH
50 #undef USE_NPTH
51 #endif
52
53 #ifdef HAVE_NPTH
54 #include <npth.h>
55 #endif
56
57 #ifdef HAVE_STAT
58 # include <sys/stat.h>
59 #endif
60
61
62 #include "util.h"
63 #include "i18n.h"
64 #include "sysutils.h"
65 #include "exechelp.h"
66
67 /* Define to 1 do enable debugging.  */
68 #define DEBUG_W32_SPAWN 0
69
70
71 /* It seems Vista doesn't grok X_OK and so fails access() tests.
72    Previous versions interpreted X_OK as F_OK anyway, so we'll just
73    use F_OK directly. */
74 #undef X_OK
75 #define X_OK F_OK
76
77 /* We assume that a HANDLE can be represented by an int which should
78    be true for all i386 systems (HANDLE is defined as void *) and
79    these are the only systems for which Windows is available.  Further
80    we assume that -1 denotes an invalid handle.  */
81 # define fd_to_handle(a)  ((HANDLE)(a))
82 # define handle_to_fd(a)  ((int)(a))
83 # define pid_to_handle(a) ((HANDLE)(a))
84 # define handle_to_pid(a) ((int)(a))
85
86
87 /* Helper */
88 static inline gpg_error_t
89 my_error_from_syserror (void)
90 {
91   return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
92 }
93
94 static inline gpg_error_t
95 my_error (int errcode)
96 {
97   return gpg_err_make (default_errsource, errcode);
98 }
99
100
101 /* Return the maximum number of currently allowed open file
102    descriptors.  Only useful on POSIX systems but returns a value on
103    other systems too.  */
104 int
105 get_max_fds (void)
106 {
107   int max_fds = -1;
108
109 #ifdef OPEN_MAX
110   if (max_fds == -1)
111     max_fds = OPEN_MAX;
112 #endif
113
114   if (max_fds == -1)
115     max_fds = 256;  /* Arbitrary limit.  */
116
117   return max_fds;
118 }
119
120
121 /* Under Windows this is a dummy function.  */
122 void
123 close_all_fds (int first, int *except)
124 {
125   (void)first;
126   (void)except;
127 }
128
129
130 /* Returns an array with all currently open file descriptors.  The end
131    of the array is marked by -1.  The caller needs to release this
132    array using the *standard free* and not with xfree.  This allow the
133    use of this function right at startup even before libgcrypt has
134    been initialized.  Returns NULL on error and sets ERRNO
135    accordingly.  */
136 int *
137 get_all_open_fds (void)
138 {
139   int *array;
140   size_t narray;
141   int fd, max_fd, idx;
142 #ifndef HAVE_STAT
143   array = calloc (1, sizeof *array);
144   if (array)
145     array[0] = -1;
146 #else /*HAVE_STAT*/
147   struct stat statbuf;
148
149   max_fd = get_max_fds ();
150   narray = 32;  /* If you change this change also t-exechelp.c.  */
151   array = calloc (narray, sizeof *array);
152   if (!array)
153     return NULL;
154
155   /* Note:  The list we return is ordered.  */
156   for (idx=0, fd=0; fd < max_fd; fd++)
157     if (!(fstat (fd, &statbuf) == -1 && errno == EBADF))
158       {
159         if (idx+1 >= narray)
160           {
161             int *tmp;
162
163             narray += (narray < 256)? 32:256;
164             tmp = realloc (array, narray * sizeof *array);
165             if (!tmp)
166               {
167                 free (array);
168                 return NULL;
169               }
170             array = tmp;
171           }
172         array[idx++] = fd;
173       }
174   array[idx] = -1;
175 #endif /*HAVE_STAT*/
176   return array;
177 }
178
179
180 /* Helper function to build_w32_commandline. */
181 static char *
182 build_w32_commandline_copy (char *buffer, const char *string)
183 {
184   char *p = buffer;
185   const char *s;
186
187   if (!*string) /* Empty string. */
188     p = stpcpy (p, "\"\"");
189   else if (strpbrk (string, " \t\n\v\f\""))
190     {
191       /* Need to do some kind of quoting.  */
192       p = stpcpy (p, "\"");
193       for (s=string; *s; s++)
194         {
195           *p++ = *s;
196           if (*s == '\"')
197             *p++ = *s;
198         }
199       *p++ = '\"';
200       *p = 0;
201     }
202   else
203     p = stpcpy (p, string);
204
205   return p;
206 }
207
208 /* Build a command line for use with W32's CreateProcess.  On success
209    CMDLINE gets the address of a newly allocated string.  */
210 static gpg_error_t
211 build_w32_commandline (const char *pgmname, const char * const *argv,
212                        char **cmdline)
213 {
214   int i, n;
215   const char *s;
216   char *buf, *p;
217
218   *cmdline = NULL;
219   n = 0;
220   s = pgmname;
221   n += strlen (s) + 1 + 2;  /* (1 space, 2 quoting */
222   for (; *s; s++)
223     if (*s == '\"')
224       n++;  /* Need to double inner quotes.  */
225   for (i=0; (s=argv[i]); i++)
226     {
227       n += strlen (s) + 1 + 2;  /* (1 space, 2 quoting */
228       for (; *s; s++)
229         if (*s == '\"')
230           n++;  /* Need to double inner quotes.  */
231     }
232   n++;
233
234   buf = p = xtrymalloc (n);
235   if (!buf)
236     return my_error_from_syserror ();
237
238   p = build_w32_commandline_copy (p, pgmname);
239   for (i=0; argv[i]; i++)
240     {
241       *p++ = ' ';
242       p = build_w32_commandline_copy (p, argv[i]);
243     }
244
245   *cmdline= buf;
246   return 0;
247 }
248
249
250 #define INHERIT_READ    1
251 #define INHERIT_WRITE   2
252 #define INHERIT_BOTH    (INHERIT_READ|INHERIT_WRITE)
253
254 /* Create pipe.  FLAGS indicates which ends are inheritable.  */
255 static int
256 create_inheritable_pipe (HANDLE filedes[2], int flags)
257 {
258   HANDLE r, w;
259   SECURITY_ATTRIBUTES sec_attr;
260
261   memset (&sec_attr, 0, sizeof sec_attr );
262   sec_attr.nLength = sizeof sec_attr;
263   sec_attr.bInheritHandle = TRUE;
264
265   if (!CreatePipe (&r, &w, &sec_attr, 0))
266     return -1;
267
268   if ((flags & INHERIT_READ) == 0)
269     if (! SetHandleInformation (r, HANDLE_FLAG_INHERIT, 0))
270       goto fail;
271
272   if ((flags & INHERIT_WRITE) == 0)
273     if (! SetHandleInformation (w, HANDLE_FLAG_INHERIT, 0))
274       goto fail;
275
276   filedes[0] = r;
277   filedes[1] = w;
278   return 0;
279
280  fail:
281   log_error ("SetHandleInformation failed: %s\n", w32_strerror (-1));
282   CloseHandle (r);
283   CloseHandle (w);
284   return -1;
285 }
286
287
288 static HANDLE
289 w32_open_null (int for_write)
290 {
291   HANDLE hfile;
292
293   hfile = CreateFileW (L"nul",
294                        for_write? GENERIC_WRITE : GENERIC_READ,
295                        FILE_SHARE_READ | FILE_SHARE_WRITE,
296                        NULL, OPEN_EXISTING, 0, NULL);
297   if (hfile == INVALID_HANDLE_VALUE)
298     log_debug ("can't open 'nul': %s\n", w32_strerror (-1));
299   return hfile;
300 }
301
302
303 static gpg_error_t
304 create_pipe_and_estream (int filedes[2], int flags,
305                          estream_t *r_fp, int outbound, int nonblock)
306 {
307   gpg_error_t err = 0;
308   HANDLE fds[2];
309
310   filedes[0] = filedes[1] = -1;
311   err = my_error (GPG_ERR_GENERAL);
312   if (!create_inheritable_pipe (fds, flags))
313     {
314       filedes[0] = _open_osfhandle (handle_to_fd (fds[0]), O_RDONLY);
315       if (filedes[0] == -1)
316         {
317           log_error ("failed to translate osfhandle %p\n", fds[0]);
318           CloseHandle (fds[1]);
319         }
320       else
321         {
322           filedes[1] = _open_osfhandle (handle_to_fd (fds[1]), O_APPEND);
323           if (filedes[1] == -1)
324             {
325               log_error ("failed to translate osfhandle %p\n", fds[1]);
326               close (filedes[0]);
327               filedes[0] = -1;
328               CloseHandle (fds[1]);
329             }
330           else
331             err = 0;
332         }
333     }
334
335   if (! err && r_fp)
336     {
337       if (!outbound)
338         *r_fp = es_fdopen (filedes[0], nonblock? "r,nonblock" : "r");
339       else
340         *r_fp = es_fdopen (filedes[1], nonblock? "w,nonblock" : "w");
341       if (!*r_fp)
342         {
343           err = my_error_from_syserror ();
344           log_error (_("error creating a stream for a pipe: %s\n"),
345                      gpg_strerror (err));
346           close (filedes[0]);
347           close (filedes[1]);
348           filedes[0] = filedes[1] = -1;
349           return err;
350         }
351     }
352
353   return err;
354 }
355
356 /* Portable function to create a pipe.  Under Windows the write end is
357    inheritable.  If R_FP is not NULL, an estream is created for the
358    read end and stored at R_FP.  */
359 gpg_error_t
360 gnupg_create_inbound_pipe (int filedes[2], estream_t *r_fp, int nonblock)
361 {
362   return create_pipe_and_estream (filedes, INHERIT_WRITE,
363                                   r_fp, 0, nonblock);
364 }
365
366
367 /* Portable function to create a pipe.  Under Windows the read end is
368    inheritable.  If R_FP is not NULL, an estream is created for the
369    write end and stored at R_FP.  */
370 gpg_error_t
371 gnupg_create_outbound_pipe (int filedes[2], estream_t *r_fp, int nonblock)
372 {
373   return create_pipe_and_estream (filedes, INHERIT_READ,
374                                   r_fp, 1, nonblock);
375 }
376
377
378 /* Portable function to create a pipe.  Under Windows both ends are
379    inheritable.  */
380 gpg_error_t
381 gnupg_create_pipe (int filedes[2])
382 {
383   return create_pipe_and_estream (filedes, INHERIT_BOTH,
384                                   NULL, 0, 0);
385 }
386
387
388 /* Fork and exec the PGMNAME, see exechelp.h for details.  */
389 gpg_error_t
390 gnupg_spawn_process (const char *pgmname, const char *argv[],
391                      int *except, void (*preexec)(void), unsigned int flags,
392                      estream_t *r_infp,
393                      estream_t *r_outfp,
394                      estream_t *r_errfp,
395                      pid_t *pid)
396 {
397   gpg_error_t err;
398   SECURITY_ATTRIBUTES sec_attr;
399   PROCESS_INFORMATION pi =
400     {
401       NULL,      /* Returns process handle.  */
402       0,         /* Returns primary thread handle.  */
403       0,         /* Returns pid.  */
404       0          /* Returns tid.  */
405     };
406   STARTUPINFO si;
407   int cr_flags;
408   char *cmdline;
409   HANDLE inpipe[2]  = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
410   HANDLE outpipe[2] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
411   HANDLE errpipe[2] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
412   estream_t infp = NULL;
413   estream_t outfp = NULL;
414   estream_t errfp = NULL;
415   HANDLE nullhd[3] = {INVALID_HANDLE_VALUE,
416                       INVALID_HANDLE_VALUE,
417                       INVALID_HANDLE_VALUE};
418   int i;
419   es_syshd_t syshd;
420   gpg_err_source_t errsource = default_errsource;
421   int nonblock = !!(flags & GNUPG_SPAWN_NONBLOCK);
422
423   (void)except; /* Not yet used.  */
424
425   if (r_infp)
426     *r_infp = NULL;
427   if (r_outfp)
428     *r_outfp = NULL;
429   if (r_errfp)
430     *r_errfp = NULL;
431   *pid = (pid_t)(-1); /* Always required.  */
432
433   if (r_infp)
434     {
435       if (create_inheritable_pipe (inpipe, INHERIT_READ))
436         {
437           err = gpg_err_make (errsource, GPG_ERR_GENERAL);
438           log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
439           return err;
440         }
441
442       syshd.type = ES_SYSHD_HANDLE;
443       syshd.u.handle = inpipe[1];
444       infp = es_sysopen (&syshd, nonblock? "w,nonblock" : "w");
445       if (!infp)
446         {
447           err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
448           log_error (_("error creating a stream for a pipe: %s\n"),
449                      gpg_strerror (err));
450           CloseHandle (inpipe[0]);
451           CloseHandle (inpipe[1]);
452           inpipe[0] = inpipe[1] = INVALID_HANDLE_VALUE;
453           return err;
454         }
455     }
456
457   if (r_outfp)
458     {
459       if (create_inheritable_pipe (outpipe, INHERIT_WRITE))
460         {
461           err = gpg_err_make (errsource, GPG_ERR_GENERAL);
462           log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
463           return err;
464         }
465
466       syshd.type = ES_SYSHD_HANDLE;
467       syshd.u.handle = outpipe[0];
468       outfp = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
469       if (!outfp)
470         {
471           err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
472           log_error (_("error creating a stream for a pipe: %s\n"),
473                      gpg_strerror (err));
474           CloseHandle (outpipe[0]);
475           CloseHandle (outpipe[1]);
476           outpipe[0] = outpipe[1] = INVALID_HANDLE_VALUE;
477           if (infp)
478             es_fclose (infp);
479           else if (inpipe[1] != INVALID_HANDLE_VALUE)
480             CloseHandle (inpipe[1]);
481           if (inpipe[0] != INVALID_HANDLE_VALUE)
482             CloseHandle (inpipe[0]);
483           return err;
484         }
485     }
486
487   if (r_errfp)
488     {
489       if (create_inheritable_pipe (errpipe, INHERIT_WRITE))
490         {
491           err = gpg_err_make (errsource, GPG_ERR_GENERAL);
492           log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
493           return err;
494         }
495
496       syshd.type = ES_SYSHD_HANDLE;
497       syshd.u.handle = errpipe[0];
498       errfp = es_sysopen (&syshd, nonblock? "r,nonblock" : "r");
499       if (!errfp)
500         {
501           err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
502           log_error (_("error creating a stream for a pipe: %s\n"),
503                      gpg_strerror (err));
504           CloseHandle (errpipe[0]);
505           CloseHandle (errpipe[1]);
506           errpipe[0] = errpipe[1] = INVALID_HANDLE_VALUE;
507           if (outfp)
508             es_fclose (outfp);
509           else if (outpipe[0] != INVALID_HANDLE_VALUE)
510             CloseHandle (outpipe[0]);
511           if (outpipe[1] != INVALID_HANDLE_VALUE)
512             CloseHandle (outpipe[1]);
513           if (infp)
514             es_fclose (infp);
515           else if (inpipe[1] != INVALID_HANDLE_VALUE)
516             CloseHandle (inpipe[1]);
517           if (inpipe[0] != INVALID_HANDLE_VALUE)
518             CloseHandle (inpipe[0]);
519           return err;
520         }
521     }
522
523   /* Prepare security attributes.  */
524   memset (&sec_attr, 0, sizeof sec_attr );
525   sec_attr.nLength = sizeof sec_attr;
526   sec_attr.bInheritHandle = FALSE;
527
528   /* Build the command line.  */
529   err = build_w32_commandline (pgmname, argv, &cmdline);
530   if (err)
531     return err;
532
533   if (inpipe[0] == INVALID_HANDLE_VALUE)
534     nullhd[0] = w32_open_null (0);
535   if (outpipe[1] == INVALID_HANDLE_VALUE)
536     nullhd[1] = w32_open_null (1);
537   if (errpipe[1] == INVALID_HANDLE_VALUE)
538     nullhd[2] = w32_open_null (1);
539
540   /* Start the process.  Note that we can't run the PREEXEC function
541      because this might change our own environment. */
542   (void)preexec;
543
544   memset (&si, 0, sizeof si);
545   si.cb = sizeof (si);
546   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
547   si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
548   si.hStdInput  = inpipe[0]  == INVALID_HANDLE_VALUE? nullhd[0] : inpipe[0];
549   si.hStdOutput = outpipe[1] == INVALID_HANDLE_VALUE? nullhd[1] : outpipe[1];
550   si.hStdError  = errpipe[1] == INVALID_HANDLE_VALUE? nullhd[2] : errpipe[1];
551
552   cr_flags = (CREATE_DEFAULT_ERROR_MODE
553               | ((flags & GNUPG_SPAWN_DETACHED)? DETACHED_PROCESS : 0)
554               | GetPriorityClass (GetCurrentProcess ())
555               | CREATE_SUSPENDED);
556 /*   log_debug ("CreateProcess, path='%s' cmdline='%s'\n", pgmname, cmdline); */
557   if (!CreateProcess (pgmname,       /* Program to start.  */
558                       cmdline,       /* Command line arguments.  */
559                       &sec_attr,     /* Process security attributes.  */
560                       &sec_attr,     /* Thread security attributes.  */
561                       TRUE,          /* Inherit handles.  */
562                       cr_flags,      /* Creation flags.  */
563                       NULL,          /* Environment.  */
564                       NULL,          /* Use current drive/directory.  */
565                       &si,           /* Startup information. */
566                       &pi            /* Returns process information.  */
567                       ))
568     {
569       log_error ("CreateProcess failed: %s\n", w32_strerror (-1));
570       xfree (cmdline);
571       if (infp)
572         es_fclose (infp);
573       else if (inpipe[1] != INVALID_HANDLE_VALUE)
574         CloseHandle (outpipe[1]);
575       if (inpipe[0] != INVALID_HANDLE_VALUE)
576         CloseHandle (inpipe[0]);
577       if (outfp)
578         es_fclose (outfp);
579       else if (outpipe[0] != INVALID_HANDLE_VALUE)
580         CloseHandle (outpipe[0]);
581       if (outpipe[1] != INVALID_HANDLE_VALUE)
582         CloseHandle (outpipe[1]);
583       if (errfp)
584         es_fclose (errfp);
585       else if (errpipe[0] != INVALID_HANDLE_VALUE)
586         CloseHandle (errpipe[0]);
587       if (errpipe[1] != INVALID_HANDLE_VALUE)
588         CloseHandle (errpipe[1]);
589       return gpg_err_make (errsource, GPG_ERR_GENERAL);
590     }
591   xfree (cmdline);
592   cmdline = NULL;
593
594   /* Close the inherited handles to /dev/null.  */
595   for (i=0; i < DIM (nullhd); i++)
596     if (nullhd[i] != INVALID_HANDLE_VALUE)
597       CloseHandle (nullhd[i]);
598
599   /* Close the inherited ends of the pipes.  */
600   if (inpipe[0] != INVALID_HANDLE_VALUE)
601     CloseHandle (inpipe[0]);
602   if (outpipe[1] != INVALID_HANDLE_VALUE)
603     CloseHandle (outpipe[1]);
604   if (errpipe[1] != INVALID_HANDLE_VALUE)
605     CloseHandle (errpipe[1]);
606
607   /* log_debug ("CreateProcess ready: hProcess=%p hThread=%p" */
608   /*            " dwProcessID=%d dwThreadId=%d\n", */
609   /*            pi.hProcess, pi.hThread, */
610   /*            (int) pi.dwProcessId, (int) pi.dwThreadId); */
611   /* log_debug ("                     outfp=%p errfp=%p\n", outfp, errfp); */
612
613   /* Fixme: For unknown reasons AllowSetForegroundWindow returns an
614      invalid argument error if we pass it the correct processID.  As a
615      workaround we use -1 (ASFW_ANY).  */
616   if ((flags & GNUPG_SPAWN_RUN_ASFW))
617     gnupg_allow_set_foregound_window ((pid_t)(-1)/*pi.dwProcessId*/);
618
619   /* Process has been created suspended; resume it now. */
620   ResumeThread (pi.hThread);
621   CloseHandle (pi.hThread);
622
623   if (r_infp)
624     *r_infp = infp;
625   if (r_outfp)
626     *r_outfp = outfp;
627   if (r_errfp)
628     *r_errfp = errfp;
629
630   *pid = handle_to_pid (pi.hProcess);
631   return 0;
632
633 }
634
635
636
637 /* Simplified version of gnupg_spawn_process.  This function forks and
638    then execs PGMNAME, while connecting INFD to stdin, OUTFD to stdout
639    and ERRFD to stderr (any of them may be -1 to connect them to
640    /dev/null).  The arguments for the process are expected in the NULL
641    terminated array ARGV.  The program name itself should not be
642    included there.  Calling gnupg_wait_process is required.
643
644    Returns 0 on success or an error code. */
645 gpg_error_t
646 gnupg_spawn_process_fd (const char *pgmname, const char *argv[],
647                         int infd, int outfd, int errfd, pid_t *pid)
648 {
649   gpg_error_t err;
650   SECURITY_ATTRIBUTES sec_attr;
651   PROCESS_INFORMATION pi = { NULL, 0, 0, 0 };
652   STARTUPINFO si;
653   char *cmdline;
654   int i;
655   HANDLE stdhd[3];
656
657   /* Setup return values.  */
658   *pid = (pid_t)(-1);
659
660   /* Prepare security attributes.  */
661   memset (&sec_attr, 0, sizeof sec_attr );
662   sec_attr.nLength = sizeof sec_attr;
663   sec_attr.bInheritHandle = FALSE;
664
665   /* Build the command line.  */
666   err = build_w32_commandline (pgmname, argv, &cmdline);
667   if (err)
668     return err;
669
670   memset (&si, 0, sizeof si);
671   si.cb = sizeof (si);
672   si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
673   si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
674   stdhd[0] = infd  == -1? w32_open_null (0) : INVALID_HANDLE_VALUE;
675   stdhd[1] = outfd == -1? w32_open_null (1) : INVALID_HANDLE_VALUE;
676   stdhd[2] = errfd == -1? w32_open_null (1) : INVALID_HANDLE_VALUE;
677   si.hStdInput  = infd  == -1? stdhd[0] : (void*)_get_osfhandle (infd);
678   si.hStdOutput = outfd == -1? stdhd[1] : (void*)_get_osfhandle (outfd);
679   si.hStdError  = errfd == -1? stdhd[2] : (void*)_get_osfhandle (errfd);
680
681 /*   log_debug ("CreateProcess, path='%s' cmdline='%s'\n", pgmname, cmdline); */
682   if (!CreateProcess (pgmname,       /* Program to start.  */
683                       cmdline,       /* Command line arguments.  */
684                       &sec_attr,     /* Process security attributes.  */
685                       &sec_attr,     /* Thread security attributes.  */
686                       TRUE,          /* Inherit handles.  */
687                       (CREATE_DEFAULT_ERROR_MODE
688                        | GetPriorityClass (GetCurrentProcess ())
689                        | CREATE_SUSPENDED | DETACHED_PROCESS),
690                       NULL,          /* Environment.  */
691                       NULL,          /* Use current drive/directory.  */
692                       &si,           /* Startup information. */
693                       &pi            /* Returns process information.  */
694                       ))
695     {
696       log_error ("CreateProcess failed: %s\n", w32_strerror (-1));
697       err = my_error (GPG_ERR_GENERAL);
698     }
699   else
700     err = 0;
701   xfree (cmdline);
702   for (i=0; i < 3; i++)
703     if (stdhd[i] != INVALID_HANDLE_VALUE)
704       CloseHandle (stdhd[i]);
705   if (err)
706     return err;
707
708 /*   log_debug ("CreateProcess ready: hProcess=%p hThread=%p" */
709 /*              " dwProcessID=%d dwThreadId=%d\n", */
710 /*              pi.hProcess, pi.hThread, */
711 /*              (int) pi.dwProcessId, (int) pi.dwThreadId); */
712
713   /* Process has been created suspended; resume it now. */
714   ResumeThread (pi.hThread);
715   CloseHandle (pi.hThread);
716
717   *pid = handle_to_pid (pi.hProcess);
718   return 0;
719
720 }
721
722
723 /* See exechelp.h for a description.  */
724 gpg_error_t
725 gnupg_wait_process (const char *pgmname, pid_t pid, int hang, int *r_exitcode)
726 {
727   return gnupg_wait_processes (&pgmname, &pid, 1, hang, r_exitcode);
728 }
729
730 /* See exechelp.h for a description.  */
731 gpg_error_t
732 gnupg_wait_processes (const char **pgmnames, pid_t *pids, size_t count,
733                       int hang, int *r_exitcodes)
734 {
735   gpg_err_code_t ec = 0;
736   size_t i;
737   HANDLE *procs;
738   int code;
739
740   procs = xtrycalloc (count, sizeof *procs);
741   if (procs == NULL)
742     return my_error_from_syserror ();
743
744   for (i = 0; i < count; i++)
745     {
746       if (r_exitcodes)
747         r_exitcodes[i] = -1;
748
749       if (pids[i] == (pid_t)(-1))
750         return my_error (GPG_ERR_INV_VALUE);
751
752       procs[i] = fd_to_handle (pids[i]);
753     }
754
755   /* FIXME: We should do a pth_waitpid here.  However this has not yet
756      been implemented.  A special W32 pth system call would even be
757      better.  */
758   code = WaitForMultipleObjects (count, procs, TRUE, hang? INFINITE : 0);
759   switch (code)
760     {
761     case WAIT_TIMEOUT:
762       ec = GPG_ERR_TIMEOUT;
763       goto leave;
764
765     case WAIT_FAILED:
766       log_error (_("waiting for processes to terminate failed: %s\n"),
767                  w32_strerror (-1));
768       ec = GPG_ERR_GENERAL;
769       goto leave;
770
771     case WAIT_OBJECT_0:
772       for (i = 0; i < count; i++)
773         {
774           DWORD exc;
775
776           if (! GetExitCodeProcess (procs[i], &exc))
777             {
778               log_error (_("error getting exit code of process %d: %s\n"),
779                          (int) pids[i], w32_strerror (-1) );
780               ec = GPG_ERR_GENERAL;
781             }
782           else if (exc)
783             {
784               if (!r_exitcodes)
785                 log_error (_("error running '%s': exit status %d\n"),
786                            pgmnames[i], (int)exc);
787               else
788                 r_exitcodes[i] = (int)exc;
789               ec = GPG_ERR_GENERAL;
790             }
791           else
792             {
793               if (r_exitcodes)
794                 r_exitcodes[i] = 0;
795             }
796         }
797       break;
798
799     default:
800       log_error ("WaitForMultipleObjects returned unexpected "
801                  "code %d\n", code);
802       ec = GPG_ERR_GENERAL;
803       break;
804     }
805
806  leave:
807   return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, ec);
808 }
809
810
811
812 void
813 gnupg_release_process (pid_t pid)
814 {
815   if (pid != (pid_t)INVALID_HANDLE_VALUE)
816     {
817       HANDLE process = (HANDLE)pid;
818
819       CloseHandle (process);
820     }
821 }
822
823
824 /* Spawn a new process and immediately detach from it.  The name of
825    the program to exec is PGMNAME and its arguments are in ARGV (the
826    programname is automatically passed as first argument).
827    Environment strings in ENVP are set.  An error is returned if
828    pgmname is not executable; to make this work it is necessary to
829    provide an absolute file name.  All standard file descriptors are
830    connected to /dev/null. */
831 gpg_error_t
832 gnupg_spawn_process_detached (const char *pgmname, const char *argv[],
833                               const char *envp[] )
834 {
835   gpg_error_t err;
836   SECURITY_ATTRIBUTES sec_attr;
837   PROCESS_INFORMATION pi =
838     {
839       NULL,      /* Returns process handle.  */
840       0,         /* Returns primary thread handle.  */
841       0,         /* Returns pid.  */
842       0          /* Returns tid.  */
843     };
844   STARTUPINFO si;
845   int cr_flags;
846   char *cmdline;
847
848
849   /* We don't use ENVP.  */
850   (void)envp;
851
852   if (access (pgmname, X_OK))
853     return my_error_from_syserror ();
854
855   /* Prepare security attributes.  */
856   memset (&sec_attr, 0, sizeof sec_attr );
857   sec_attr.nLength = sizeof sec_attr;
858   sec_attr.bInheritHandle = FALSE;
859
860   /* Build the command line.  */
861   err = build_w32_commandline (pgmname, argv, &cmdline);
862   if (err)
863     return err;
864
865   /* Start the process.  */
866   memset (&si, 0, sizeof si);
867   si.cb = sizeof (si);
868   si.dwFlags = STARTF_USESHOWWINDOW;
869   si.wShowWindow = DEBUG_W32_SPAWN? SW_SHOW : SW_MINIMIZE;
870
871   cr_flags = (CREATE_DEFAULT_ERROR_MODE
872               | GetPriorityClass (GetCurrentProcess ())
873               | CREATE_NEW_PROCESS_GROUP
874               | DETACHED_PROCESS);
875 /*   log_debug ("CreateProcess(detached), path='%s' cmdline='%s'\n", */
876 /*              pgmname, cmdline); */
877   if (!CreateProcess (pgmname,       /* Program to start.  */
878                       cmdline,       /* Command line arguments.  */
879                       &sec_attr,     /* Process security attributes.  */
880                       &sec_attr,     /* Thread security attributes.  */
881                       FALSE,         /* Inherit handles.  */
882                       cr_flags,      /* Creation flags.  */
883                       NULL,          /* Environment.  */
884                       NULL,          /* Use current drive/directory.  */
885                       &si,           /* Startup information. */
886                       &pi            /* Returns process information.  */
887                       ))
888     {
889       log_error ("CreateProcess(detached) failed: %s\n", w32_strerror (-1));
890       xfree (cmdline);
891       return my_error (GPG_ERR_GENERAL);
892     }
893   xfree (cmdline);
894   cmdline = NULL;
895
896 /*   log_debug ("CreateProcess(detached) ready: hProcess=%p hThread=%p" */
897 /*              " dwProcessID=%d dwThreadId=%d\n", */
898 /*              pi.hProcess, pi.hThread, */
899 /*              (int) pi.dwProcessId, (int) pi.dwThreadId); */
900
901   CloseHandle (pi.hThread);
902   CloseHandle (pi.hProcess);
903
904   return 0;
905 }
906
907
908 /* Kill a process; that is send an appropriate signal to the process.
909    gnupg_wait_process must be called to actually remove the process
910    from the system.  An invalid PID is ignored.  */
911 void
912 gnupg_kill_process (pid_t pid)
913 {
914   if (pid != (pid_t) INVALID_HANDLE_VALUE)
915     {
916       HANDLE process = (HANDLE) pid;
917
918       /* Arbitrary error code.  */
919       TerminateProcess (process, 1);
920     }
921 }