common: New function log_debug_with_string.
[gnupg.git] / common / exechelp-posix.c
1 /* exechelp.c - Fork and exec helpers for POSIX
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 POSIX
35 #endif
36
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <stdint.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <assert.h>
43 #ifdef HAVE_SIGNAL_H
44 # include <signal.h>
45 #endif
46 #include <unistd.h>
47 #include <fcntl.h>
48
49 #ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth.  */
50 #undef HAVE_NPTH
51 #undef USE_NPTH
52 #endif
53
54 #ifdef HAVE_NPTH
55 #include <npth.h>
56 #endif
57 #include <sys/wait.h>
58
59 #ifdef HAVE_GETRLIMIT
60 #include <sys/time.h>
61 #include <sys/resource.h>
62 #endif /*HAVE_GETRLIMIT*/
63
64 #ifdef HAVE_STAT
65 # include <sys/stat.h>
66 #endif
67
68 #if __linux__
69 # include <sys/types.h>
70 # include <dirent.h>
71 #endif /*__linux__ */
72
73 #include "util.h"
74 #include "i18n.h"
75 #include "sysutils.h"
76 #include "exechelp.h"
77
78
79 /* Helper */
80 static inline gpg_error_t
81 my_error_from_syserror (void)
82 {
83   return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
84 }
85
86 static inline gpg_error_t
87 my_error (int errcode)
88 {
89   return gpg_err_make (default_errsource, errcode);
90 }
91
92
93 /* Return the maximum number of currently allowed open file
94    descriptors.  Only useful on POSIX systems but returns a value on
95    other systems too.  */
96 int
97 get_max_fds (void)
98 {
99   int max_fds = -1;
100 #ifdef HAVE_GETRLIMIT
101   struct rlimit rl;
102
103   /* Under Linux we can figure out the highest used file descriptor by
104    * reading /proc/PID/fd.  This is in the common cases much fast than
105    * for example doing 4096 close calls where almost all of them will
106    * fail.  On a system with a limit of 4096 files and only 8 files
107    * open with the highest number being 10, we speedup close_all_fds
108    * from 125ms to 0.4ms including readdir.
109    *
110    * Another option would be to close the file descriptors as returned
111    * from reading that directory - however then we need to snapshot
112    * that list before starting to close them.  */
113 #ifdef __linux__
114   {
115     DIR *dir = NULL;
116     struct dirent *dir_entry;
117     const char *s;
118     int x;
119
120     dir = opendir ("/proc/self/fd");
121     if (dir)
122       {
123         while ((dir_entry = readdir (dir)))
124           {
125             s = dir_entry->d_name;
126             if ( *s < '0' || *s > '9')
127               continue;
128             x = atoi (s);
129             if (x > max_fds)
130               max_fds = x;
131           }
132         closedir (dir);
133       }
134     if (max_fds != -1)
135       return max_fds + 1;
136     }
137 #endif /* __linux__ */
138
139
140 # ifdef RLIMIT_NOFILE
141   if (!getrlimit (RLIMIT_NOFILE, &rl))
142     max_fds = rl.rlim_max;
143 # endif
144
145 # ifdef RLIMIT_OFILE
146   if (max_fds == -1 && !getrlimit (RLIMIT_OFILE, &rl))
147     max_fds = rl.rlim_max;
148
149 # endif
150 #endif /*HAVE_GETRLIMIT*/
151
152 #ifdef _SC_OPEN_MAX
153   if (max_fds == -1)
154     {
155       long int scres = sysconf (_SC_OPEN_MAX);
156       if (scres >= 0)
157         max_fds = scres;
158     }
159 #endif
160
161 #ifdef _POSIX_OPEN_MAX
162   if (max_fds == -1)
163     max_fds = _POSIX_OPEN_MAX;
164 #endif
165
166 #ifdef OPEN_MAX
167   if (max_fds == -1)
168     max_fds = OPEN_MAX;
169 #endif
170
171   if (max_fds == -1)
172     max_fds = 256;  /* Arbitrary limit.  */
173
174   /* AIX returns INT32_MAX instead of a proper value.  We assume that
175      this is always an error and use an arbitrary limit.  */
176 #ifdef INT32_MAX
177   if (max_fds == INT32_MAX)
178     max_fds = 256;
179 #endif
180
181   return max_fds;
182 }
183
184
185 /* Close all file descriptors starting with descriptor FIRST.  If
186    EXCEPT is not NULL, it is expected to be a list of file descriptors
187    which shall not be closed.  This list shall be sorted in ascending
188    order with the end marked by -1.  */
189 void
190 close_all_fds (int first, int *except)
191 {
192   int max_fd = get_max_fds ();
193   int fd, i, except_start;
194
195   if (except)
196     {
197       except_start = 0;
198       for (fd=first; fd < max_fd; fd++)
199         {
200           for (i=except_start; except[i] != -1; i++)
201             {
202               if (except[i] == fd)
203                 {
204                   /* If we found the descriptor in the exception list
205                      we can start the next compare run at the next
206                      index because the exception list is ordered.  */
207                 except_start = i + 1;
208                 break;
209                 }
210             }
211           if (except[i] == -1)
212             close (fd);
213         }
214     }
215   else
216     {
217       for (fd=first; fd < max_fd; fd++)
218         close (fd);
219     }
220
221   gpg_err_set_errno (0);
222 }
223
224
225 /* Returns an array with all currently open file descriptors.  The end
226    of the array is marked by -1.  The caller needs to release this
227    array using the *standard free* and not with xfree.  This allow the
228    use of this function right at startup even before libgcrypt has
229    been initialized.  Returns NULL on error and sets ERRNO
230    accordingly.  */
231 int *
232 get_all_open_fds (void)
233 {
234   int *array;
235   size_t narray;
236   int fd, max_fd, idx;
237 #ifndef HAVE_STAT
238   array = calloc (1, sizeof *array);
239   if (array)
240     array[0] = -1;
241 #else /*HAVE_STAT*/
242   struct stat statbuf;
243
244   max_fd = get_max_fds ();
245   narray = 32;  /* If you change this change also t-exechelp.c.  */
246   array = calloc (narray, sizeof *array);
247   if (!array)
248     return NULL;
249
250   /* Note:  The list we return is ordered.  */
251   for (idx=0, fd=0; fd < max_fd; fd++)
252     if (!(fstat (fd, &statbuf) == -1 && errno == EBADF))
253       {
254         if (idx+1 >= narray)
255           {
256             int *tmp;
257
258             narray += (narray < 256)? 32:256;
259             tmp = realloc (array, narray * sizeof *array);
260             if (!tmp)
261               {
262                 free (array);
263                 return NULL;
264               }
265             array = tmp;
266           }
267         array[idx++] = fd;
268       }
269   array[idx] = -1;
270 #endif /*HAVE_STAT*/
271   return array;
272 }
273
274
275 /* The exec core used right after the fork. This will never return. */
276 static void
277 do_exec (const char *pgmname, const char *argv[],
278          int fd_in, int fd_out, int fd_err,
279          int *except, void (*preexec)(void) )
280 {
281   char **arg_list;
282   int i, j;
283   int fds[3];
284
285   fds[0] = fd_in;
286   fds[1] = fd_out;
287   fds[2] = fd_err;
288
289   /* Create the command line argument array.  */
290   i = 0;
291   if (argv)
292     while (argv[i])
293       i++;
294   arg_list = xcalloc (i+2, sizeof *arg_list);
295   arg_list[0] = strrchr (pgmname, '/');
296   if (arg_list[0])
297     arg_list[0]++;
298   else
299     arg_list[0] = xstrdup (pgmname);
300   if (argv)
301     for (i=0,j=1; argv[i]; i++, j++)
302       arg_list[j] = (char*)argv[i];
303
304   /* Assign /dev/null to unused FDs. */
305   for (i=0; i <= 2; i++)
306     {
307       if (fds[i] == -1 )
308         {
309           fds[i] = open ("/dev/null", i? O_WRONLY : O_RDONLY);
310           if (fds[i] == -1)
311             log_fatal ("failed to open '%s': %s\n",
312                        "/dev/null", strerror (errno));
313         }
314     }
315
316   /* Connect the standard files.  */
317   for (i=0; i <= 2; i++)
318     {
319       if (fds[i] != i && dup2 (fds[i], i) == -1)
320         log_fatal ("dup2 std%s failed: %s\n",
321                    i==0?"in":i==1?"out":"err", strerror (errno));
322     }
323
324   /* Close all other files. */
325   close_all_fds (3, except);
326
327   if (preexec)
328     preexec ();
329   execv (pgmname, arg_list);
330   /* No way to print anything, as we have closed all streams. */
331   _exit (127);
332 }
333
334
335 static gpg_error_t
336 do_create_pipe (int filedes[2])
337 {
338   gpg_error_t err = 0;
339
340   if (pipe (filedes) == -1)
341     {
342       err = my_error_from_syserror ();
343       filedes[0] = filedes[1] = -1;
344     }
345
346   return err;
347 }
348
349
350 static gpg_error_t
351 create_pipe_and_estream (int filedes[2], estream_t *r_fp,
352                          int outbound, int nonblock)
353 {
354   gpg_error_t err;
355
356   if (pipe (filedes) == -1)
357     {
358       err = my_error_from_syserror ();
359       log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
360       filedes[0] = filedes[1] = -1;
361       *r_fp = NULL;
362       return err;
363     }
364
365   if (!outbound)
366     *r_fp = es_fdopen (filedes[0], nonblock? "r,nonblock" : "r");
367   else
368     *r_fp = es_fdopen (filedes[1], nonblock? "w,nonblock" : "w");
369   if (!*r_fp)
370     {
371       err = my_error_from_syserror ();
372       log_error (_("error creating a stream for a pipe: %s\n"),
373                  gpg_strerror (err));
374       close (filedes[0]);
375       close (filedes[1]);
376       filedes[0] = filedes[1] = -1;
377       return err;
378     }
379   return 0;
380 }
381
382
383 /* Portable function to create a pipe.  Under Windows the write end is
384    inheritable.  If R_FP is not NULL, an estream is created for the
385    read end and stored at R_FP.  */
386 gpg_error_t
387 gnupg_create_inbound_pipe (int filedes[2], estream_t *r_fp, int nonblock)
388 {
389   if (r_fp)
390     return create_pipe_and_estream (filedes, r_fp, 0, nonblock);
391   else
392     return do_create_pipe (filedes);
393 }
394
395
396 /* Portable function to create a pipe.  Under Windows the read end is
397    inheritable.  If R_FP is not NULL, an estream is created for the
398    write end and stored at R_FP.  */
399 gpg_error_t
400 gnupg_create_outbound_pipe (int filedes[2], estream_t *r_fp, int nonblock)
401 {
402   if (r_fp)
403     return create_pipe_and_estream (filedes, r_fp, 1, nonblock);
404   else
405     return do_create_pipe (filedes);
406 }
407
408
409 /* Portable function to create a pipe.  Under Windows both ends are
410    inheritable.  */
411 gpg_error_t
412 gnupg_create_pipe (int filedes[2])
413 {
414   return do_create_pipe (filedes);
415 }
416
417
418 /* Fork and exec the PGMNAME, see exechelp.h for details.  */
419 gpg_error_t
420 gnupg_spawn_process (const char *pgmname, const char *argv[],
421                      int *except, void (*preexec)(void), unsigned int flags,
422                      estream_t *r_infp,
423                      estream_t *r_outfp,
424                      estream_t *r_errfp,
425                      pid_t *pid)
426 {
427   gpg_error_t err;
428   int inpipe[2] = {-1, -1};
429   int outpipe[2] = {-1, -1};
430   int errpipe[2] = {-1, -1};
431   estream_t infp = NULL;
432   estream_t outfp = NULL;
433   estream_t errfp = NULL;
434   int nonblock = !!(flags & GNUPG_SPAWN_NONBLOCK);
435
436   if (r_infp)
437     *r_infp = NULL;
438   if (r_outfp)
439     *r_outfp = NULL;
440   if (r_errfp)
441     *r_errfp = NULL;
442   *pid = (pid_t)(-1); /* Always required.  */
443
444   if (r_infp)
445     {
446       err = create_pipe_and_estream (inpipe, &infp, 1, nonblock);
447       if (err)
448         return err;
449     }
450
451   if (r_outfp)
452     {
453       err = create_pipe_and_estream (outpipe, &outfp, 0, nonblock);
454       if (err)
455         {
456           if (infp)
457             es_fclose (infp);
458           else if (inpipe[1] != -1)
459             close (inpipe[1]);
460           if (inpipe[0] != -1)
461             close (inpipe[0]);
462
463           return err;
464         }
465     }
466
467   if (r_errfp)
468     {
469       err = create_pipe_and_estream (errpipe, &errfp, 0, nonblock);
470       if (err)
471         {
472           if (infp)
473             es_fclose (infp);
474           else if (inpipe[1] != -1)
475             close (inpipe[1]);
476           if (inpipe[0] != -1)
477             close (inpipe[0]);
478
479           if (outfp)
480             es_fclose (outfp);
481           else if (outpipe[0] != -1)
482             close (outpipe[0]);
483           if (outpipe[1] != -1)
484             close (outpipe[1]);
485
486           return err;
487         }
488     }
489
490
491   *pid = fork ();
492   if (*pid == (pid_t)(-1))
493     {
494       err = my_error_from_syserror ();
495       log_error (_("error forking process: %s\n"), gpg_strerror (err));
496
497       if (infp)
498         es_fclose (infp);
499       else if (inpipe[1] != -1)
500         close (inpipe[1]);
501       if (inpipe[0] != -1)
502         close (inpipe[0]);
503
504       if (outfp)
505         es_fclose (outfp);
506       else if (outpipe[0] != -1)
507         close (outpipe[0]);
508       if (outpipe[1] != -1)
509         close (outpipe[1]);
510
511       if (errfp)
512         es_fclose (errfp);
513       else if (errpipe[0] != -1)
514         close (errpipe[0]);
515       if (errpipe[1] != -1)
516         close (errpipe[1]);
517       return err;
518     }
519
520   if (!*pid)
521     {
522       /* This is the child. */
523       gcry_control (GCRYCTL_TERM_SECMEM);
524       es_fclose (infp);
525       es_fclose (outfp);
526       es_fclose (errfp);
527       do_exec (pgmname, argv, inpipe[0], outpipe[1], errpipe[1],
528                except, preexec);
529       /*NOTREACHED*/
530     }
531
532   /* This is the parent. */
533   if (inpipe[0] != -1)
534     close (inpipe[0]);
535   if (outpipe[1] != -1)
536     close (outpipe[1]);
537   if (errpipe[1] != -1)
538     close (errpipe[1]);
539
540   if (r_infp)
541     *r_infp = infp;
542   if (r_outfp)
543     *r_outfp = outfp;
544   if (r_errfp)
545     *r_errfp = errfp;
546
547   return 0;
548 }
549
550
551
552 /* Simplified version of gnupg_spawn_process.  This function forks and
553    then execs PGMNAME, while connecting INFD to stdin, OUTFD to stdout
554    and ERRFD to stderr (any of them may be -1 to connect them to
555    /dev/null).  The arguments for the process are expected in the NULL
556    terminated array ARGV.  The program name itself should not be
557    included there.  Calling gnupg_wait_process is required.
558
559    Returns 0 on success or an error code. */
560 gpg_error_t
561 gnupg_spawn_process_fd (const char *pgmname, const char *argv[],
562                         int infd, int outfd, int errfd, pid_t *pid)
563 {
564   gpg_error_t err;
565
566   *pid = fork ();
567   if (*pid == (pid_t)(-1))
568     {
569       err = my_error_from_syserror ();
570       log_error (_("error forking process: %s\n"), strerror (errno));
571       return err;
572     }
573
574   if (!*pid)
575     {
576       gcry_control (GCRYCTL_TERM_SECMEM);
577       /* Run child. */
578       do_exec (pgmname, argv, infd, outfd, errfd, NULL, NULL);
579       /*NOTREACHED*/
580     }
581
582   return 0;
583 }
584
585
586 \f
587
588 /* Waiting for child processes.
589
590    waitpid(2) may return information about terminated children that we
591    did not yet request, and there is no portable way to wait for a
592    specific set of children.
593
594    As a workaround, we store the results of children for later use.
595
596    XXX: This assumes that PIDs are not reused too quickly.  */
597
598 struct terminated_child
599 {
600   pid_t pid;
601   int exitcode;
602   struct terminated_child *next;
603 };
604
605 struct terminated_child *terminated_children;
606
607
608 static gpg_error_t
609 store_result (pid_t pid, int exitcode)
610 {
611   struct terminated_child *c;
612
613   c = xtrymalloc (sizeof *c);
614   if (c == NULL)
615     return gpg_err_code_from_syserror ();
616
617   c->pid = pid;
618   c->exitcode = exitcode;
619   c->next = terminated_children;
620   terminated_children = c;
621
622   return 0;
623 }
624
625
626 static int
627 get_result (pid_t pid, int *r_exitcode)
628 {
629   struct terminated_child *c, **prevp;
630
631   for (prevp = &terminated_children, c = terminated_children;
632        c;
633        prevp = &c->next, c = c->next)
634     if (c->pid == pid)
635       {
636         *prevp = c->next;
637         *r_exitcode = c->exitcode;
638         xfree (c);
639         return 1;
640       }
641
642   return 0;
643 }
644
645
646 /* See exechelp.h for a description.  */
647 gpg_error_t
648 gnupg_wait_process (const char *pgmname, pid_t pid, int hang, int *r_exitcode)
649 {
650   gpg_err_code_t ec;
651   int i, status;
652
653   if (r_exitcode)
654     *r_exitcode = -1;
655
656   if (pid == (pid_t)(-1))
657     return gpg_error (GPG_ERR_INV_VALUE);
658
659 #ifdef USE_NPTH
660   i = npth_waitpid (pid, &status, hang? 0:WNOHANG);
661 #else
662   while ((i=waitpid (pid, &status, hang? 0:WNOHANG)) == (pid_t)(-1)
663          && errno == EINTR);
664 #endif
665
666   if (i == (pid_t)(-1))
667     {
668       ec = gpg_err_code_from_errno (errno);
669       log_error (_("waiting for process %d to terminate failed: %s\n"),
670                  (int)pid, strerror (errno));
671     }
672   else if (!i)
673     {
674       ec = GPG_ERR_TIMEOUT; /* Still running.  */
675     }
676   else if (WIFEXITED (status) && WEXITSTATUS (status) == 127)
677     {
678       log_error (_("error running '%s': probably not installed\n"), pgmname);
679       ec = GPG_ERR_CONFIGURATION;
680     }
681   else if (WIFEXITED (status) && WEXITSTATUS (status))
682     {
683       if (!r_exitcode)
684         log_error (_("error running '%s': exit status %d\n"), pgmname,
685                    WEXITSTATUS (status));
686       else
687         *r_exitcode = WEXITSTATUS (status);
688       ec = GPG_ERR_GENERAL;
689     }
690   else if (!WIFEXITED (status))
691     {
692       log_error (_("error running '%s': terminated\n"), pgmname);
693       ec = GPG_ERR_GENERAL;
694     }
695   else
696     {
697       if (r_exitcode)
698         *r_exitcode = 0;
699       ec = 0;
700     }
701
702   return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, ec);
703 }
704
705 /* See exechelp.h for a description.  */
706 gpg_error_t
707 gnupg_wait_processes (const char **pgmnames, pid_t *pids, size_t count,
708                       int hang, int *r_exitcodes)
709 {
710   gpg_err_code_t ec = 0;
711   size_t i, left;
712   int *dummy = NULL;
713
714   if (r_exitcodes == NULL)
715     {
716       dummy = r_exitcodes = xtrymalloc (sizeof *r_exitcodes * count);
717       if (dummy == NULL)
718         return gpg_err_code_from_syserror ();
719     }
720
721   for (i = 0, left = count; i < count; i++)
722     {
723       int status = -1;
724
725       if (pids[i] == (pid_t)(-1))
726         return my_error (GPG_ERR_INV_VALUE);
727
728       /* See if there was a previously stored result for this pid.  */
729       if (get_result (pids[i], &status))
730         left -= 1;
731
732       r_exitcodes[i] = status;
733     }
734
735   while (left > 0)
736     {
737       pid_t pid;
738       int status;
739
740 #ifdef USE_NPTH
741       pid = npth_waitpid (-1, &status, hang ? 0 : WNOHANG);
742 #else
743       while ((pid = waitpid (-1, &status, hang ? 0 : WNOHANG)) == (pid_t)(-1)
744              && errno == EINTR);
745 #endif
746
747       if (pid == (pid_t)(-1))
748         {
749           ec = gpg_err_code_from_errno (errno);
750           log_error (_("waiting for processes to terminate failed: %s\n"),
751                      strerror (errno));
752           break;
753         }
754       else if (!pid)
755         {
756           ec = GPG_ERR_TIMEOUT; /* Still running.  */
757           break;
758         }
759       else
760         {
761           for (i = 0; i < count; i++)
762             if (pid == pids[i])
763               break;
764
765           if (i == count)
766             {
767               /* No match, store this result.  */
768               ec = store_result (pid, status);
769               if (ec)
770                 break;
771               continue;
772             }
773
774           /* Process PIDS[i] died.  */
775           if (r_exitcodes[i] != (pid_t) -1)
776             {
777               log_error ("PID %d was reused", pid);
778               ec = GPG_ERR_GENERAL;
779               break;
780             }
781
782           left -= 1;
783           r_exitcodes[i] = status;
784         }
785     }
786
787   if (ec == 0)
788     for (i = 0; i < count; i++)
789       {
790         if (WIFEXITED (r_exitcodes[i]) && WEXITSTATUS (r_exitcodes[i]) == 127)
791           {
792             log_error (_("error running '%s': probably not installed\n"),
793                        pgmnames[i]);
794             ec = GPG_ERR_CONFIGURATION;
795           }
796         else if (WIFEXITED (r_exitcodes[i]) && WEXITSTATUS (r_exitcodes[i]))
797           {
798             if (dummy)
799               log_error (_("error running '%s': exit status %d\n"),
800                          pgmnames[i], WEXITSTATUS (r_exitcodes[i]));
801             else
802               r_exitcodes[i] = WEXITSTATUS (r_exitcodes[i]);
803             ec = GPG_ERR_GENERAL;
804           }
805         else if (!WIFEXITED (r_exitcodes[i]))
806           {
807             log_error (_("error running '%s': terminated\n"), pgmnames[i]);
808             ec = GPG_ERR_GENERAL;
809           }
810       }
811
812   xfree (dummy);
813   return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, ec);
814 }
815
816 \f
817
818 void
819 gnupg_release_process (pid_t pid)
820 {
821   (void)pid;
822 }
823
824
825 /* Spawn a new process and immediately detach from it.  The name of
826    the program to exec is PGMNAME and its arguments are in ARGV (the
827    programname is automatically passed as first argument).
828    Environment strings in ENVP are set.  An error is returned if
829    pgmname is not executable; to make this work it is necessary to
830    provide an absolute file name.  All standard file descriptors are
831    connected to /dev/null. */
832 gpg_error_t
833 gnupg_spawn_process_detached (const char *pgmname, const char *argv[],
834                               const char *envp[] )
835 {
836   pid_t pid;
837   int i;
838
839   if (getuid() != geteuid())
840     return my_error (GPG_ERR_BUG);
841
842   if (access (pgmname, X_OK))
843     return my_error_from_syserror ();
844
845   pid = fork ();
846   if (pid == (pid_t)(-1))
847     {
848       log_error (_("error forking process: %s\n"), strerror (errno));
849       return my_error_from_syserror ();
850     }
851   if (!pid)
852     {
853       pid_t pid2;
854
855       gcry_control (GCRYCTL_TERM_SECMEM);
856       if (setsid() == -1 || chdir ("/"))
857         _exit (1);
858
859       pid2 = fork (); /* Double fork to let init take over the new child. */
860       if (pid2 == (pid_t)(-1))
861         _exit (1);
862       if (pid2)
863         _exit (0);  /* Let the parent exit immediately. */
864
865       if (envp)
866         for (i=0; envp[i]; i++)
867           putenv (xstrdup (envp[i]));
868
869       do_exec (pgmname, argv, -1, -1, -1, NULL, NULL);
870
871       /*NOTREACHED*/
872     }
873
874   if (waitpid (pid, NULL, 0) == -1)
875     log_error ("waitpid failed in gnupg_spawn_process_detached: %s",
876                strerror (errno));
877
878   return 0;
879 }
880
881
882 /* Kill a process; that is send an appropriate signal to the process.
883    gnupg_wait_process must be called to actually remove the process
884    from the system.  An invalid PID is ignored.  */
885 void
886 gnupg_kill_process (pid_t pid)
887 {
888   if (pid != (pid_t)(-1))
889     {
890       kill (pid, SIGTERM);
891     }
892 }