common: Close input 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 (infp);
527       es_fclose (outfp);
528       es_fclose (errfp);
529       do_exec (pgmname, argv, inpipe[0], outpipe[1], errpipe[1],
530                except, preexec);
531       /*NOTREACHED*/
532     }
533
534   /* This is the parent. */
535   if (inpipe[0] != -1)
536     close (inpipe[0]);
537   if (outpipe[1] != -1)
538     close (outpipe[1]);
539   if (errpipe[1] != -1)
540     close (errpipe[1]);
541
542   if (r_infp)
543     *r_infp = infp;
544   if (r_outfp)
545     *r_outfp = outfp;
546   if (r_errfp)
547     *r_errfp = errfp;
548
549   return 0;
550 }
551
552
553
554 /* Simplified version of gnupg_spawn_process.  This function forks and
555    then execs PGMNAME, while connecting INFD to stdin, OUTFD to stdout
556    and ERRFD to stderr (any of them may be -1 to connect them to
557    /dev/null).  The arguments for the process are expected in the NULL
558    terminated array ARGV.  The program name itself should not be
559    included there.  Calling gnupg_wait_process is required.
560
561    Returns 0 on success or an error code. */
562 gpg_error_t
563 gnupg_spawn_process_fd (const char *pgmname, const char *argv[],
564                         int infd, int outfd, int errfd, pid_t *pid)
565 {
566   gpg_error_t err;
567
568   *pid = fork ();
569   if (*pid == (pid_t)(-1))
570     {
571       err = my_error_from_syserror ();
572       log_error (_("error forking process: %s\n"), strerror (errno));
573       return err;
574     }
575
576   if (!*pid)
577     {
578       gcry_control (GCRYCTL_TERM_SECMEM);
579       /* Run child. */
580       do_exec (pgmname, argv, infd, outfd, errfd, NULL, NULL);
581       /*NOTREACHED*/
582     }
583
584   return 0;
585 }
586
587
588 /* See exechelp.h for a description.  */
589 gpg_error_t
590 gnupg_wait_process (const char *pgmname, pid_t pid, int hang, int *r_exitcode)
591 {
592   return gnupg_wait_processes (&pgmname, &pid, 1, hang, r_exitcode);
593 }
594
595 /* See exechelp.h for a description.  */
596 gpg_error_t
597 gnupg_wait_processes (const char **pgmnames, pid_t *pids, size_t count,
598                       int hang, int *r_exitcodes)
599 {
600   gpg_err_code_t ec = 0;
601   size_t i, left;
602
603   for (i = 0; i < count; i++)
604     {
605       if (r_exitcodes)
606         r_exitcodes[i] = -1;
607
608       if (pids[i] == (pid_t)(-1))
609         return my_error (GPG_ERR_INV_VALUE);
610     }
611
612   left = count;
613   while (left > 0)
614     {
615       pid_t pid;
616       int status;
617
618 #ifdef USE_NPTH
619       pid = npth_waitpid (-1, &status, hang ? 0 : WNOHANG);
620 #else
621       while ((pid = waitpid (-1, &status, hang ? 0 : WNOHANG)) == (pid_t)(-1)
622              && errno == EINTR);
623 #endif
624
625       if (pid == (pid_t)(-1))
626         {
627           ec = gpg_err_code_from_errno (errno);
628           log_error (_("waiting for processes to terminate failed: %s\n"),
629                      strerror (errno));
630           break;
631         }
632       else if (!pid)
633         {
634           ec = GPG_ERR_TIMEOUT; /* Still running.  */
635           break;
636         }
637       else
638         {
639           for (i = 0; i < count; i++)
640             if (pid == pids[i])
641               break;
642
643           if (i == count)
644             /* No match, ignore this pid.  */
645             continue;
646
647           /* Process PIDS[i] died.  */
648           left -= 1;
649
650           if (WIFEXITED (status) && WEXITSTATUS (status) == 127)
651             {
652               log_error (_("error running '%s': probably not installed\n"),
653                          pgmnames[i]);
654               ec = GPG_ERR_CONFIGURATION;
655             }
656           else if (WIFEXITED (status) && WEXITSTATUS (status))
657             {
658               if (!r_exitcodes)
659                 log_error (_("error running '%s': exit status %d\n"),
660                            pgmnames[i], WEXITSTATUS (status));
661               else
662                 r_exitcodes[i] = WEXITSTATUS (status);
663               ec = GPG_ERR_GENERAL;
664             }
665           else if (!WIFEXITED (status))
666             {
667               log_error (_("error running '%s': terminated\n"), pgmnames[i]);
668               ec = GPG_ERR_GENERAL;
669             }
670           else
671             {
672               if (r_exitcodes)
673                 r_exitcodes[i] = 0;
674             }
675         }
676     }
677
678   return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, ec);
679 }
680
681
682 void
683 gnupg_release_process (pid_t pid)
684 {
685   (void)pid;
686 }
687
688
689 /* Spawn a new process and immediately detach from it.  The name of
690    the program to exec is PGMNAME and its arguments are in ARGV (the
691    programname is automatically passed as first argument).
692    Environment strings in ENVP are set.  An error is returned if
693    pgmname is not executable; to make this work it is necessary to
694    provide an absolute file name.  All standard file descriptors are
695    connected to /dev/null. */
696 gpg_error_t
697 gnupg_spawn_process_detached (const char *pgmname, const char *argv[],
698                               const char *envp[] )
699 {
700   pid_t pid;
701   int i;
702
703   if (getuid() != geteuid())
704     return my_error (GPG_ERR_BUG);
705
706   if (access (pgmname, X_OK))
707     return my_error_from_syserror ();
708
709   pid = fork ();
710   if (pid == (pid_t)(-1))
711     {
712       log_error (_("error forking process: %s\n"), strerror (errno));
713       return my_error_from_syserror ();
714     }
715   if (!pid)
716     {
717       pid_t pid2;
718
719       gcry_control (GCRYCTL_TERM_SECMEM);
720       if (setsid() == -1 || chdir ("/"))
721         _exit (1);
722
723       pid2 = fork (); /* Double fork to let init take over the new child. */
724       if (pid2 == (pid_t)(-1))
725         _exit (1);
726       if (pid2)
727         _exit (0);  /* Let the parent exit immediately. */
728
729       if (envp)
730         for (i=0; envp[i]; i++)
731           putenv (xstrdup (envp[i]));
732
733       do_exec (pgmname, argv, -1, -1, -1, NULL, NULL);
734
735       /*NOTREACHED*/
736     }
737
738   if (waitpid (pid, NULL, 0) == -1)
739     log_error ("waitpid failed in gnupg_spawn_process_detached: %s",
740                strerror (errno));
741
742   return 0;
743 }
744
745
746 /* Kill a process; that is send an appropriate signal to the process.
747    gnupg_wait_process must be called to actually remove the process
748    from the system.  An invalid PID is ignored.  */
749 void
750 gnupg_kill_process (pid_t pid)
751 {
752   if (pid != (pid_t)(-1))
753     {
754       kill (pid, SIGTERM);
755     }
756 }