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