common: Add new function gnupg_gmtime.
[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 #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 #include <sys/wait.h>
57
58 #ifdef HAVE_GETRLIMIT
59 #include <sys/time.h>
60 #include <sys/resource.h>
61 #endif /*HAVE_GETRLIMIT*/
62
63 #ifdef HAVE_STAT
64 # include <sys/stat.h>
65 #endif
66
67 #include "util.h"
68 #include "i18n.h"
69 #include "sysutils.h"
70 #include "exechelp.h"
71
72
73 /* Return the maximum number of currently allowed open file
74    descriptors.  Only useful on POSIX systems but returns a value on
75    other systems too.  */
76 int
77 get_max_fds (void)
78 {
79   int max_fds = -1;
80 #ifdef HAVE_GETRLIMIT
81   struct rlimit rl;
82
83 # ifdef RLIMIT_NOFILE
84   if (!getrlimit (RLIMIT_NOFILE, &rl))
85     max_fds = rl.rlim_max;
86 # endif
87
88 # ifdef RLIMIT_OFILE
89   if (max_fds == -1 && !getrlimit (RLIMIT_OFILE, &rl))
90     max_fds = rl.rlim_max;
91
92 # endif
93 #endif /*HAVE_GETRLIMIT*/
94
95 #ifdef _SC_OPEN_MAX
96   if (max_fds == -1)
97     {
98       long int scres = sysconf (_SC_OPEN_MAX);
99       if (scres >= 0)
100         max_fds = scres;
101     }
102 #endif
103
104 #ifdef _POSIX_OPEN_MAX
105   if (max_fds == -1)
106     max_fds = _POSIX_OPEN_MAX;
107 #endif
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 /* Close all file descriptors starting with descriptor FIRST.  If
122    EXCEPT is not NULL, it is expected to be a list of file descriptors
123    which shall not be closed.  This list shall be sorted in ascending
124    order with the end marked by -1.  */
125 void
126 close_all_fds (int first, int *except)
127 {
128   int max_fd = get_max_fds ();
129   int fd, i, except_start;
130
131   if (except)
132     {
133       except_start = 0;
134       for (fd=first; fd < max_fd; fd++)
135         {
136           for (i=except_start; except[i] != -1; i++)
137             {
138               if (except[i] == fd)
139                 {
140                   /* If we found the descriptor in the exception list
141                      we can start the next compare run at the next
142                      index because the exception list is ordered.  */
143                 except_start = i + 1;
144                 break;
145                 }
146             }
147           if (except[i] == -1)
148             close (fd);
149         }
150     }
151   else
152     {
153       for (fd=first; fd < max_fd; fd++)
154         close (fd);
155     }
156
157   gpg_err_set_errno (0);
158 }
159
160
161 /* Returns an array with all currently open file descriptors.  The end
162    of the array is marked by -1.  The caller needs to release this
163    array using the *standard free* and not with xfree.  This allow the
164    use of this fucntion right at startup even before libgcrypt has
165    been initialized.  Returns NULL on error and sets ERRNO
166    accordingly.  */
167 int *
168 get_all_open_fds (void)
169 {
170   int *array;
171   size_t narray;
172   int fd, max_fd, idx;
173 #ifndef HAVE_STAT
174   array = calloc (1, sizeof *array);
175   if (array)
176     array[0] = -1;
177 #else /*HAVE_STAT*/
178   struct stat statbuf;
179
180   max_fd = get_max_fds ();
181   narray = 32;  /* If you change this change also t-exechelp.c.  */
182   array = calloc (narray, sizeof *array);
183   if (!array)
184     return NULL;
185
186   /* Note:  The list we return is ordered.  */
187   for (idx=0, fd=0; fd < max_fd; fd++)
188     if (!(fstat (fd, &statbuf) == -1 && errno == EBADF))
189       {
190         if (idx+1 >= narray)
191           {
192             int *tmp;
193
194             narray += (narray < 256)? 32:256;
195             tmp = realloc (array, narray * sizeof *array);
196             if (!tmp)
197               {
198                 free (array);
199                 return NULL;
200               }
201             array = tmp;
202           }
203         array[idx++] = fd;
204       }
205   array[idx] = -1;
206 #endif /*HAVE_STAT*/
207   return array;
208 }
209
210
211 /* The exec core used right after the fork. This will never return. */
212 static void
213 do_exec (const char *pgmname, const char *argv[],
214          int fd_in, int fd_out, int fd_err,
215          void (*preexec)(void) )
216 {
217   char **arg_list;
218   int i, j;
219   int fds[3];
220
221   fds[0] = fd_in;
222   fds[1] = fd_out;
223   fds[2] = fd_err;
224
225   /* Create the command line argument array.  */
226   i = 0;
227   if (argv)
228     while (argv[i])
229       i++;
230   arg_list = xcalloc (i+2, sizeof *arg_list);
231   arg_list[0] = strrchr (pgmname, '/');
232   if (arg_list[0])
233     arg_list[0]++;
234   else
235     arg_list[0] = xstrdup (pgmname);
236   if (argv)
237     for (i=0,j=1; argv[i]; i++, j++)
238       arg_list[j] = (char*)argv[i];
239
240   /* Assign /dev/null to unused FDs. */
241   for (i=0; i <= 2; i++)
242     {
243       if (fds[i] == -1 )
244         {
245           fds[i] = open ("/dev/null", i? O_WRONLY : O_RDONLY);
246           if (fds[i] == -1)
247             log_fatal ("failed to open '%s': %s\n",
248                        "/dev/null", strerror (errno));
249         }
250     }
251
252   /* Connect the standard files.  */
253   for (i=0; i <= 2; i++)
254     {
255       if (fds[i] != i && dup2 (fds[i], i) == -1)
256         log_fatal ("dup2 std%s failed: %s\n",
257                    i==0?"in":i==1?"out":"err", strerror (errno));
258     }
259
260   /* Close all other files. */
261   close_all_fds (3, NULL);
262
263   if (preexec)
264     preexec ();
265   execv (pgmname, arg_list);
266   /* No way to print anything, as we have closed all streams. */
267   _exit (127);
268 }
269
270
271 static gpg_error_t
272 do_create_pipe (int filedes[2])
273 {
274   gpg_error_t err = 0;
275
276   if (pipe (filedes) == -1)
277     {
278       err = gpg_error_from_syserror ();
279       filedes[0] = filedes[1] = -1;
280     }
281
282   return err;
283 }
284
285 /* Portable function to create a pipe.  Under Windows the write end is
286    inheritable.  */
287 gpg_error_t
288 gnupg_create_inbound_pipe (int filedes[2])
289 {
290   return do_create_pipe (filedes);
291 }
292
293
294 /* Portable function to create a pipe.  Under Windows the read end is
295    inheritable.  */
296 gpg_error_t
297 gnupg_create_outbound_pipe (int filedes[2])
298 {
299   return do_create_pipe (filedes);
300 }
301
302
303
304 static gpg_error_t
305 create_pipe_and_estream (int filedes[2], estream_t *r_fp,
306                          gpg_err_source_t errsource)
307 {
308   gpg_error_t err;
309
310   if (pipe (filedes) == -1)
311     {
312       err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
313       log_error (_("error creating a pipe: %s\n"), gpg_strerror (err));
314       filedes[0] = filedes[1] = -1;
315       *r_fp = NULL;
316       return err;
317     }
318
319   *r_fp = es_fdopen (filedes[0], "r");
320   if (!*r_fp)
321     {
322       err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
323       log_error (_("error creating a stream for a pipe: %s\n"),
324                  gpg_strerror (err));
325       close (filedes[0]);
326       close (filedes[1]);
327       filedes[0] = filedes[1] = -1;
328       return err;
329     }
330   return 0;
331 }
332
333
334
335 /* Fork and exec the PGMNAME, see exechelp.h for details.  */
336 gpg_error_t
337 gnupg_spawn_process (const char *pgmname, const char *argv[],
338                      gpg_err_source_t errsource,
339                      void (*preexec)(void), unsigned int flags,
340                      estream_t infp,
341                      estream_t *r_outfp,
342                      estream_t *r_errfp,
343                      pid_t *pid)
344 {
345   gpg_error_t err;
346   int infd = -1;
347   int outpipe[2] = {-1, -1};
348   int errpipe[2] = {-1, -1};
349   estream_t outfp = NULL;
350   estream_t errfp = NULL;
351
352   (void)flags; /* Currently not used.  */
353
354   if (r_outfp)
355     *r_outfp = NULL;
356   if (r_errfp)
357     *r_errfp = NULL;
358   *pid = (pid_t)(-1); /* Always required.  */
359
360   if (infp)
361     {
362       es_fflush (infp);
363       es_rewind (infp);
364       infd = es_fileno (infp);
365       if (infd == -1)
366         return gpg_err_make (errsource, GPG_ERR_INV_VALUE);
367     }
368
369   if (r_outfp)
370     {
371       err = create_pipe_and_estream (outpipe, &outfp, errsource);
372       if (err)
373         return err;
374     }
375
376   if (r_errfp)
377     {
378       err = create_pipe_and_estream (errpipe, &errfp, errsource);
379       if (err)
380         {
381           if (outfp)
382             es_fclose (outfp);
383           else if (outpipe[0] != -1)
384             close (outpipe[0]);
385           if (outpipe[1] != -1)
386             close (outpipe[1]);
387           return err;
388         }
389     }
390
391
392   *pid = fork ();
393   if (*pid == (pid_t)(-1))
394     {
395       err = gpg_err_make (errsource, gpg_err_code_from_syserror ());
396       log_error (_("error forking process: %s\n"), gpg_strerror (err));
397
398       if (outfp)
399         es_fclose (outfp);
400       else if (outpipe[0] != -1)
401         close (outpipe[0]);
402       if (outpipe[1] != -1)
403         close (outpipe[1]);
404
405       if (errfp)
406         es_fclose (errfp);
407       else if (errpipe[0] != -1)
408         close (errpipe[0]);
409       if (errpipe[1] != -1)
410         close (errpipe[1]);
411       return err;
412     }
413
414   if (!*pid)
415     {
416       /* This is the child. */
417       gcry_control (GCRYCTL_TERM_SECMEM);
418       es_fclose (outfp);
419       es_fclose (errfp);
420       do_exec (pgmname, argv, infd, outpipe[1], errpipe[1], preexec);
421       /*NOTREACHED*/
422     }
423
424   /* This is the parent. */
425   if (outpipe[1] != -1)
426     close (outpipe[1]);
427   if (errpipe[1] != -1)
428     close (errpipe[1]);
429
430   if (r_outfp)
431     *r_outfp = outfp;
432   if (r_errfp)
433     *r_errfp = errfp;
434
435   return 0;
436 }
437
438
439
440 /* Simplified version of gnupg_spawn_process.  This function forks and
441    then execs PGMNAME, while connecting INFD to stdin, OUTFD to stdout
442    and ERRFD to stderr (any of them may be -1 to connect them to
443    /dev/null).  The arguments for the process are expected in the NULL
444    terminated array ARGV.  The program name itself should not be
445    included there.  Calling gnupg_wait_process is required.
446
447    Returns 0 on success or an error code. */
448 gpg_error_t
449 gnupg_spawn_process_fd (const char *pgmname, const char *argv[],
450                         int infd, int outfd, int errfd, pid_t *pid)
451 {
452   gpg_error_t err;
453
454   *pid = fork ();
455   if (*pid == (pid_t)(-1))
456     {
457       err = gpg_error_from_syserror ();
458       log_error (_("error forking process: %s\n"), strerror (errno));
459       return err;
460     }
461
462   if (!*pid)
463     {
464       gcry_control (GCRYCTL_TERM_SECMEM);
465       /* Run child. */
466       do_exec (pgmname, argv, infd, outfd, errfd, NULL);
467       /*NOTREACHED*/
468     }
469
470   return 0;
471 }
472
473
474 /* See exechelp.h for the description.  */
475 gpg_error_t
476 gnupg_wait_process (const char *pgmname, pid_t pid, int hang, int *r_exitcode)
477 {
478   gpg_err_code_t ec;
479   int i, status;
480
481   if (r_exitcode)
482     *r_exitcode = -1;
483
484   if (pid == (pid_t)(-1))
485     return gpg_error (GPG_ERR_INV_VALUE);
486
487 #ifdef USE_NPTH
488   i = npth_waitpid (pid, &status, hang? 0:WNOHANG);
489 #else
490   while ((i=waitpid (pid, &status, hang? 0:WNOHANG)) == (pid_t)(-1)
491          && errno == EINTR);
492 #endif
493
494   if (i == (pid_t)(-1))
495     {
496       ec = gpg_err_code_from_errno (errno);
497       log_error (_("waiting for process %d to terminate failed: %s\n"),
498                  (int)pid, strerror (errno));
499     }
500   else if (!i)
501     {
502       ec = GPG_ERR_TIMEOUT; /* Still running.  */
503     }
504   else if (WIFEXITED (status) && WEXITSTATUS (status) == 127)
505     {
506       log_error (_("error running '%s': probably not installed\n"), pgmname);
507       ec = GPG_ERR_CONFIGURATION;
508     }
509   else if (WIFEXITED (status) && WEXITSTATUS (status))
510     {
511       if (!r_exitcode)
512         log_error (_("error running '%s': exit status %d\n"), pgmname,
513                    WEXITSTATUS (status));
514       else
515         *r_exitcode = WEXITSTATUS (status);
516       ec = GPG_ERR_GENERAL;
517     }
518   else if (!WIFEXITED (status))
519     {
520       log_error (_("error running '%s': terminated\n"), pgmname);
521       ec = GPG_ERR_GENERAL;
522     }
523   else
524     {
525       if (r_exitcode)
526         *r_exitcode = 0;
527       ec = 0;
528     }
529
530   return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, ec);
531 }
532
533
534 void
535 gnupg_release_process (pid_t pid)
536 {
537   (void)pid;
538 }
539
540
541 /* Spawn a new process and immediately detach from it.  The name of
542    the program to exec is PGMNAME and its arguments are in ARGV (the
543    programname is automatically passed as first argument).
544    Environment strings in ENVP are set.  An error is returned if
545    pgmname is not executable; to make this work it is necessary to
546    provide an absolute file name.  All standard file descriptors are
547    connected to /dev/null. */
548 gpg_error_t
549 gnupg_spawn_process_detached (const char *pgmname, const char *argv[],
550                               const char *envp[] )
551 {
552   pid_t pid;
553   int i;
554
555   if (getuid() != geteuid())
556     return gpg_error (GPG_ERR_BUG);
557
558   if (access (pgmname, X_OK))
559     return gpg_error_from_syserror ();
560
561   pid = fork ();
562   if (pid == (pid_t)(-1))
563     {
564       log_error (_("error forking process: %s\n"), strerror (errno));
565       return gpg_error_from_syserror ();
566     }
567   if (!pid)
568     {
569       pid_t pid2;
570
571       gcry_control (GCRYCTL_TERM_SECMEM);
572       if (setsid() == -1 || chdir ("/"))
573         _exit (1);
574
575       pid2 = fork (); /* Double fork to let init take over the new child. */
576       if (pid2 == (pid_t)(-1))
577         _exit (1);
578       if (pid2)
579         _exit (0);  /* Let the parent exit immediately. */
580
581       if (envp)
582         for (i=0; envp[i]; i++)
583           putenv (xstrdup (envp[i]));
584
585       do_exec (pgmname, argv, -1, -1, -1, NULL);
586
587       /*NOTREACHED*/
588     }
589
590   if (waitpid (pid, NULL, 0) == -1)
591     log_error ("waitpid failed in gnupg_spawn_process_detached: %s",
592                strerror (errno));
593
594   return 0;
595 }
596
597
598 /* Kill a process; that is send an appropriate signal to the process.
599    gnupg_wait_process must be called to actually remove the process
600    from the system.  An invalid PID is ignored.  */
601 void
602 gnupg_kill_process (pid_t pid)
603 {
604   if (pid != (pid_t)(-1))
605     {
606       kill (pid, SIGTERM);
607     }
608 }