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