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