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