a7a9a929d28d306aebbaddf8f04bbb4b76a22c39
[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          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, NULL);
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                      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], 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);
579       /*NOTREACHED*/
580     }
581
582   return 0;
583 }
584
585
586 /* See exechelp.h for a description.  */
587 gpg_error_t
588 gnupg_wait_process (const char *pgmname, pid_t pid, int hang, int *r_exitcode)
589 {
590   return gnupg_wait_processes (&pgmname, &pid, 1, hang, r_exitcode);
591 }
592
593 /* See exechelp.h for a description.  */
594 gpg_error_t
595 gnupg_wait_processes (const char **pgmnames, pid_t *pids, size_t count,
596                       int hang, int *r_exitcodes)
597 {
598   gpg_err_code_t ec = 0;
599   size_t i, left;
600
601   for (i = 0; i < count; i++)
602     {
603       if (r_exitcodes)
604         r_exitcodes[i] = -1;
605
606       if (pids[i] == (pid_t)(-1))
607         return my_error (GPG_ERR_INV_VALUE);
608     }
609
610   left = count;
611   while (left > 0)
612     {
613       pid_t pid;
614       int status;
615
616 #ifdef USE_NPTH
617       pid = npth_waitpid (-1, &status, hang ? 0 : WNOHANG);
618 #else
619       while ((pid = waitpid (-1, &status, hang ? 0 : WNOHANG)) == (pid_t)(-1)
620              && errno == EINTR);
621 #endif
622
623       if (pid == (pid_t)(-1))
624         {
625           ec = gpg_err_code_from_errno (errno);
626           log_error (_("waiting for processes to terminate failed: %s\n"),
627                      strerror (errno));
628           break;
629         }
630       else if (!pid)
631         {
632           ec = GPG_ERR_TIMEOUT; /* Still running.  */
633           break;
634         }
635       else
636         {
637           for (i = 0; i < count; i++)
638             if (pid == pids[i])
639               break;
640
641           if (i == count)
642             /* No match, ignore this pid.  */
643             continue;
644
645           /* Process PIDS[i] died.  */
646           left -= 1;
647
648           if (WIFEXITED (status) && WEXITSTATUS (status) == 127)
649             {
650               log_error (_("error running '%s': probably not installed\n"),
651                          pgmnames[i]);
652               ec = GPG_ERR_CONFIGURATION;
653             }
654           else if (WIFEXITED (status) && WEXITSTATUS (status))
655             {
656               if (!r_exitcodes)
657                 log_error (_("error running '%s': exit status %d\n"),
658                            pgmnames[i], WEXITSTATUS (status));
659               else
660                 r_exitcodes[i] = WEXITSTATUS (status);
661               ec = GPG_ERR_GENERAL;
662             }
663           else if (!WIFEXITED (status))
664             {
665               log_error (_("error running '%s': terminated\n"), pgmnames[i]);
666               ec = GPG_ERR_GENERAL;
667             }
668           else
669             {
670               if (r_exitcodes)
671                 r_exitcodes[i] = 0;
672             }
673         }
674     }
675
676   return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, ec);
677 }
678
679
680 void
681 gnupg_release_process (pid_t pid)
682 {
683   (void)pid;
684 }
685
686
687 /* Spawn a new process and immediately detach from it.  The name of
688    the program to exec is PGMNAME and its arguments are in ARGV (the
689    programname is automatically passed as first argument).
690    Environment strings in ENVP are set.  An error is returned if
691    pgmname is not executable; to make this work it is necessary to
692    provide an absolute file name.  All standard file descriptors are
693    connected to /dev/null. */
694 gpg_error_t
695 gnupg_spawn_process_detached (const char *pgmname, const char *argv[],
696                               const char *envp[] )
697 {
698   pid_t pid;
699   int i;
700
701   if (getuid() != geteuid())
702     return my_error (GPG_ERR_BUG);
703
704   if (access (pgmname, X_OK))
705     return my_error_from_syserror ();
706
707   pid = fork ();
708   if (pid == (pid_t)(-1))
709     {
710       log_error (_("error forking process: %s\n"), strerror (errno));
711       return my_error_from_syserror ();
712     }
713   if (!pid)
714     {
715       pid_t pid2;
716
717       gcry_control (GCRYCTL_TERM_SECMEM);
718       if (setsid() == -1 || chdir ("/"))
719         _exit (1);
720
721       pid2 = fork (); /* Double fork to let init take over the new child. */
722       if (pid2 == (pid_t)(-1))
723         _exit (1);
724       if (pid2)
725         _exit (0);  /* Let the parent exit immediately. */
726
727       if (envp)
728         for (i=0; envp[i]; i++)
729           putenv (xstrdup (envp[i]));
730
731       do_exec (pgmname, argv, -1, -1, -1, NULL);
732
733       /*NOTREACHED*/
734     }
735
736   if (waitpid (pid, NULL, 0) == -1)
737     log_error ("waitpid failed in gnupg_spawn_process_detached: %s",
738                strerror (errno));
739
740   return 0;
741 }
742
743
744 /* Kill a process; that is send an appropriate signal to the process.
745    gnupg_wait_process must be called to actually remove the process
746    from the system.  An invalid PID is ignored.  */
747 void
748 gnupg_kill_process (pid_t pid)
749 {
750   if (pid != (pid_t)(-1))
751     {
752       kill (pid, SIGTERM);
753     }
754 }