doc: Fix description of the field 11.
[gnupg.git] / common / exectool.c
1 /* exectool.c - Utility functions to execute a helper tool
2  * Copyright (C) 2015 Werner Koch
3  * Copyright (C) 2016 g10 Code GmbH
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 <https://www.gnu.org/licenses/>.
29  */
30
31 #include <config.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdarg.h>
36 #include <errno.h>
37 #include <assert.h>
38 #include <gpg-error.h>
39
40 #include <assuan.h>
41 #include "i18n.h"
42 #include "logging.h"
43 #include "membuf.h"
44 #include "mischelp.h"
45 #include "exechelp.h"
46 #include "sysutils.h"
47 #include "util.h"
48 #include "exectool.h"
49
50 typedef struct
51 {
52   const char *pgmname;
53   exec_tool_status_cb_t status_cb;
54   void *status_cb_value;
55   int cont;
56   int quiet;
57   size_t used;
58   size_t buffer_size;
59   char *buffer;
60 } read_and_log_buffer_t;
61
62
63 static inline gpg_error_t
64 my_error_from_syserror (void)
65 {
66   return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
67 }
68
69
70 static void
71 read_and_log_stderr (read_and_log_buffer_t *state, es_poll_t *fderr)
72 {
73   gpg_error_t err;
74   int c;
75
76   if (!fderr)
77     {
78       /* Flush internal buffer.  */
79       if (state->used)
80         {
81           const char *pname;
82           int len;
83
84           state->buffer[state->used] = 0;
85           state->used = 0;
86
87           pname = strrchr (state->pgmname, '/');
88           if (pname && pname != state->pgmname && pname[1])
89             pname++;
90           else
91             pname = state->pgmname;
92           len = strlen (pname);
93
94           if (state->status_cb
95               && !strncmp (state->buffer, "[GNUPG:] ", 9)
96               && state->buffer[9] >= 'A' && state->buffer[9] <= 'Z')
97             {
98               char *rest;
99
100               rest = strchr (state->buffer + 9, ' ');
101               if (!rest)
102                 {
103                   /* Set REST to an empty string.  */
104                   rest = state->buffer + strlen (state->buffer);
105                 }
106               else
107                 {
108                   *rest++ = 0;
109                   trim_spaces (rest);
110                 }
111               state->status_cb (state->status_cb_value,
112                                 state->buffer + 9, rest);
113             }
114           else if (state->quiet)
115             ;
116           else if (!state->cont
117               && !strncmp (state->buffer, pname, len)
118               && strlen (state->buffer) > strlen (pname)
119               && state->buffer[len] == ':' )
120             {
121               /* PGMNAME plus colon is identical to the start of
122                  the output: print only the output.  */
123               log_info ("%s\n", state->buffer);
124             }
125           else
126             log_info ("%s%c %s\n",
127                       pname, state->cont? '+':':', state->buffer);
128         }
129       state->cont = 0;
130       return;
131     }
132   for (;;)
133     {
134       c = es_fgetc (fderr->stream);
135       if (c == EOF)
136         {
137           if (es_feof (fderr->stream))
138             {
139               fderr->ignore = 1; /* Not anymore needed.  */
140             }
141           else if (es_ferror (fderr->stream))
142             {
143               err = my_error_from_syserror ();
144               log_error ("error reading stderr of '%s': %s\n",
145                          state->pgmname, gpg_strerror (err));
146               fderr->ignore = 1; /* Disable.  */
147             }
148
149           break;
150         }
151       else if (c == '\n')
152         {
153           read_and_log_stderr (state, NULL);
154         }
155       else
156         {
157           if (state->used >= state->buffer_size - 1)
158             {
159               if (state->status_cb)
160                 {
161                   /* A status callback requires that we have a full
162                    * line.  Thus we need to enlarget the buffer in
163                    * this case.  */
164                   char *newbuffer;
165                   size_t newsize = state->buffer_size + 256;
166
167                   newbuffer = xtrymalloc (newsize);
168                   if (!newbuffer)
169                     {
170                       log_error ("error allocating memory for status cb: %s\n",
171                                  gpg_strerror (my_error_from_syserror ()));
172                       /* We better disable the status CB in this case.  */
173                       state->status_cb = NULL;
174                       read_and_log_stderr (state, NULL);
175                       state->cont = 1;
176                     }
177                   else
178                     {
179                       memcpy (newbuffer, state->buffer, state->used);
180                       xfree (state->buffer);
181                       state->buffer = newbuffer;
182                       state->buffer_size = newsize;
183                     }
184                 }
185               else
186                 {
187                   read_and_log_stderr (state, NULL);
188                   state->cont = 1;
189                 }
190             }
191           state->buffer[state->used++] = c;
192         }
193     }
194 }
195
196 \f
197
198 /* A buffer to copy from one stream to another.  */
199 struct copy_buffer
200 {
201   char buffer[4096];
202   char *writep;
203   size_t nread;
204 };
205
206
207 /* Initialize a copy buffer.  */
208 static void
209 copy_buffer_init (struct copy_buffer *c)
210 {
211   c->writep = c->buffer;
212   c->nread = 0;
213 }
214
215
216 /* Securely wipe a copy buffer.  */
217 static void
218 copy_buffer_shred (struct copy_buffer *c)
219 {
220   if (c == NULL)
221     return;
222   wipememory (c->buffer, sizeof c->buffer);
223   c->writep = NULL;
224   c->nread = ~0U;
225 }
226
227
228 /* Copy data from SOURCE to SINK using copy buffer C.  */
229 static gpg_error_t
230 copy_buffer_do_copy (struct copy_buffer *c, estream_t source, estream_t sink)
231 {
232   gpg_error_t err;
233   size_t nwritten = 0;
234
235   if (c->nread == 0)
236     {
237       c->writep = c->buffer;
238       if (es_read (source, c->buffer, sizeof c->buffer, &c->nread))
239         {
240           err = my_error_from_syserror ();
241           if (gpg_err_code (err) == GPG_ERR_EAGAIN)
242             return 0;   /* We will just retry next time.  */
243
244           return err;
245         }
246
247       log_assert (c->nread <= sizeof c->buffer);
248     }
249
250   if (c->nread == 0)
251     return 0;   /* Done copying.  */
252
253   nwritten = 0;
254   if (sink && es_write (sink, c->writep, c->nread, &nwritten))
255     err = my_error_from_syserror ();
256   else
257     err = 0;
258
259   log_assert (nwritten <= c->nread);
260   c->writep += nwritten;
261   c->nread -= nwritten;
262   log_assert (c->writep - c->buffer <= sizeof c->buffer);
263
264   if (err)
265     {
266       if (gpg_err_code (err) == GPG_ERR_EAGAIN)
267         return 0;       /* We will just retry next time.  */
268
269       return err;
270     }
271
272   if (sink && es_fflush (sink) && errno != EAGAIN)
273     err = my_error_from_syserror ();
274
275   return err;
276 }
277
278
279 /* Flush the remaining data to SINK.  */
280 static gpg_error_t
281 copy_buffer_flush (struct copy_buffer *c, estream_t sink)
282 {
283   gpg_error_t err = 0;
284   size_t nwritten = 0;
285
286   if (es_write (sink, c->writep, c->nread, &nwritten))
287     err = my_error_from_syserror ();
288
289   log_assert (nwritten <= c->nread);
290   c->writep += nwritten;
291   c->nread -= nwritten;
292   log_assert (c->writep - c->buffer <= sizeof c->buffer);
293
294   if (err)
295     return err;
296
297   if (es_fflush (sink))
298     err = my_error_from_syserror ();
299
300   return err;
301 }
302
303 \f
304
305 /* Run the program PGMNAME with the command line arguments given in
306  * the NULL terminates array ARGV.  If INPUT is not NULL it will be
307  * fed to stdin of the process.  stderr is logged using log_info and
308  * the process' stdout is written to OUTPUT.  If OUTPUT is NULL the
309  * output is discarded.  If INEXTRA is given, an additional input
310  * stream will be passed to the child; to tell the child about this
311  * ARGV is scanned and the first occurrence of an argument
312  * "-&@INEXTRA@" is replaced by the concatenation of "-&" and the
313  * child's file descriptor of the pipe created for the INEXTRA stream.
314  *
315  * On error a diagnostic is printed and an error code returned.  */
316 gpg_error_t
317 gnupg_exec_tool_stream (const char *pgmname, const char *argv[],
318                         estream_t input, estream_t inextra,
319                         estream_t output,
320                         exec_tool_status_cb_t status_cb,
321                         void *status_cb_value)
322 {
323   gpg_error_t err;
324   pid_t pid = (pid_t) -1;
325   estream_t infp = NULL;
326   estream_t extrafp = NULL;
327   estream_t outfp = NULL, errfp = NULL;
328   es_poll_t fds[4];
329   int exceptclose[2];
330   int extrapipe[2] = {-1, -1};
331   char extrafdbuf[20];
332   const char *argsave = NULL;
333   int argsaveidx;
334   int count;
335   read_and_log_buffer_t fderrstate;
336   struct copy_buffer *cpbuf_in = NULL, *cpbuf_out = NULL, *cpbuf_extra = NULL;
337   int quiet = 0;
338   int dummy_exitcode;
339
340   memset (fds, 0, sizeof fds);
341   memset (&fderrstate, 0, sizeof fderrstate);
342
343   /* If the first argument to the program is "--quiet" avoid all extra
344    * diagnostics.  */
345   quiet = (argv && argv[0] && !strcmp (argv[0], "--quiet"));
346
347   cpbuf_in = xtrymalloc (sizeof *cpbuf_in);
348   if (cpbuf_in == NULL)
349     {
350       err = my_error_from_syserror ();
351       goto leave;
352     }
353   copy_buffer_init (cpbuf_in);
354
355   cpbuf_out = xtrymalloc (sizeof *cpbuf_out);
356   if (cpbuf_out == NULL)
357     {
358       err = my_error_from_syserror ();
359       goto leave;
360     }
361   copy_buffer_init (cpbuf_out);
362
363   cpbuf_extra = xtrymalloc (sizeof *cpbuf_extra);
364   if (cpbuf_extra == NULL)
365     {
366       err = my_error_from_syserror ();
367       goto leave;
368     }
369   copy_buffer_init (cpbuf_extra);
370
371   fderrstate.pgmname = pgmname;
372   fderrstate.quiet = quiet;
373   fderrstate.status_cb = status_cb;
374   fderrstate.status_cb_value = status_cb_value;
375   fderrstate.buffer_size = 256;
376   fderrstate.buffer = xtrymalloc (fderrstate.buffer_size);
377   if (!fderrstate.buffer)
378     {
379       err = my_error_from_syserror ();
380       goto leave;
381     }
382
383   if (inextra)
384     {
385       err = gnupg_create_outbound_pipe (extrapipe, &extrafp, 1);
386       if (err)
387         {
388           log_error ("error creating outbound pipe for extra fp: %s\n",
389                      gpg_strerror (err));
390           goto leave;
391         }
392       exceptclose[0] = extrapipe[0]; /* Do not close in child. */
393       exceptclose[1] = -1;
394       /* Now find the argument marker and replace by the pipe's fd.
395          Yeah, that is an ugly non-thread safe hack but it safes us to
396          create a copy of the array.  */
397 #ifdef HAVE_W32_SYSTEM
398       snprintf (extrafdbuf, sizeof extrafdbuf, "-&%lu",
399                 (unsigned long)(void*)_get_osfhandle (extrapipe[0]));
400 #else
401       snprintf (extrafdbuf, sizeof extrafdbuf, "-&%d", extrapipe[0]);
402 #endif
403       for (argsaveidx=0; argv[argsaveidx]; argsaveidx++)
404         if (!strcmp (argv[argsaveidx], "-&@INEXTRA@"))
405           {
406             argsave = argv[argsaveidx];
407             argv[argsaveidx] = extrafdbuf;
408             break;
409           }
410     }
411   else
412     exceptclose[0] = -1;
413
414   err = gnupg_spawn_process (pgmname, argv,
415                              exceptclose, NULL, GNUPG_SPAWN_NONBLOCK,
416                              input? &infp : NULL,
417                              &outfp, &errfp, &pid);
418   if (extrapipe[0] != -1)
419     close (extrapipe[0]);
420   if (argsave)
421     argv[argsaveidx] = argsave;
422   if (err)
423     {
424       if (!quiet)
425         log_error ("error running '%s': %s\n", pgmname, gpg_strerror (err));
426       goto leave;
427     }
428
429   fds[0].stream = infp;
430   fds[0].want_write = 1;
431   if (!input)
432     fds[0].ignore = 1;
433   fds[1].stream = outfp;
434   fds[1].want_read = 1;
435   fds[2].stream = errfp;
436   fds[2].want_read = 1;
437   fds[3].stream = extrafp;
438   fds[3].want_write = 1;
439   if (!inextra)
440     fds[3].ignore = 1;
441
442   /* Now read as long as we have something to poll.  We continue
443      reading even after EOF or error on stdout so that we get the
444      other error messages or remaining output.  */
445   while (! (fds[1].ignore && fds[2].ignore))
446     {
447       count = es_poll (fds, DIM(fds), -1);
448       if (count == -1)
449         {
450           err = my_error_from_syserror ();
451           log_error ("error polling '%s': %s\n", pgmname, gpg_strerror (err));
452           goto leave;
453         }
454       if (!count)
455         {
456           log_debug ("unexpected timeout while polling '%s'\n", pgmname);
457           break;
458         }
459
460       if (fds[0].got_write)
461         {
462           err = copy_buffer_do_copy (cpbuf_in, input, fds[0].stream);
463           if (err)
464             {
465               log_error ("error feeding data to '%s': %s\n",
466                          pgmname, gpg_strerror (err));
467               goto leave;
468             }
469
470           if (es_feof (input))
471             {
472               err = copy_buffer_flush (cpbuf_in, fds[0].stream);
473               if (gpg_err_code (err) == GPG_ERR_EAGAIN)
474                 continue;       /* Retry next time.  */
475               if (err)
476                 {
477                   log_error ("error feeding data to '%s': %s\n",
478                              pgmname, gpg_strerror (err));
479                   goto leave;
480                 }
481
482               fds[0].ignore = 1; /* ready.  */
483               es_fclose (infp); infp = NULL;
484             }
485         }
486
487       if (fds[3].got_write)
488         {
489           log_assert (inextra);
490           err = copy_buffer_do_copy (cpbuf_extra, inextra, fds[3].stream);
491           if (err)
492             {
493               log_error ("error feeding data to '%s': %s\n",
494                          pgmname, gpg_strerror (err));
495               goto leave;
496             }
497
498           if (es_feof (inextra))
499             {
500               err = copy_buffer_flush (cpbuf_extra, fds[3].stream);
501               if (gpg_err_code (err) == GPG_ERR_EAGAIN)
502                 continue;       /* Retry next time.  */
503               if (err)
504                 {
505                   log_error ("error feeding data to '%s': %s\n",
506                              pgmname, gpg_strerror (err));
507                   goto leave;
508                 }
509
510               fds[3].ignore = 1; /* ready.  */
511               es_fclose (extrafp); extrafp = NULL;
512             }
513         }
514
515       if (fds[1].got_read)
516         {
517           err = copy_buffer_do_copy (cpbuf_out, fds[1].stream, output);
518           if (err)
519             {
520               log_error ("error reading data from '%s': %s\n",
521                          pgmname, gpg_strerror (err));
522               goto leave;
523             }
524
525           if (es_feof (fds[1].stream))
526             {
527               err = copy_buffer_flush (cpbuf_out, output);
528               if (err)
529                 {
530                   log_error ("error reading data from '%s': %s\n",
531                              pgmname, gpg_strerror (err));
532                   goto leave;
533                 }
534
535               fds[1].ignore = 1; /* ready.  */
536             }
537         }
538
539       if (fds[2].got_read)
540         read_and_log_stderr (&fderrstate, fds + 2);
541     }
542
543   read_and_log_stderr (&fderrstate, NULL); /* Flush.  */
544   es_fclose (infp); infp = NULL;
545   es_fclose (extrafp); extrafp = NULL;
546   es_fclose (outfp); outfp = NULL;
547   es_fclose (errfp); errfp = NULL;
548
549   err = gnupg_wait_process (pgmname, pid, 1, quiet? &dummy_exitcode : NULL);
550   pid = (pid_t)(-1);
551
552  leave:
553   if (err && pid != (pid_t) -1)
554     gnupg_kill_process (pid);
555
556   es_fclose (infp);
557   es_fclose (extrafp);
558   es_fclose (outfp);
559   es_fclose (errfp);
560   if (pid != (pid_t)(-1))
561     gnupg_wait_process (pgmname, pid, 1,  quiet? &dummy_exitcode : NULL);
562   gnupg_release_process (pid);
563
564   copy_buffer_shred (cpbuf_in);
565   xfree (cpbuf_in);
566   copy_buffer_shred (cpbuf_out);
567   xfree (cpbuf_out);
568   copy_buffer_shred (cpbuf_extra);
569   xfree (cpbuf_extra);
570   xfree (fderrstate.buffer);
571   return err;
572 }
573
574
575 /* A dummy free function to pass to 'es_mopen'.  */
576 static void
577 nop_free (void *ptr)
578 {
579   (void) ptr;
580 }
581
582 /* Run the program PGMNAME with the command line arguments given in
583    the NULL terminates array ARGV.  If INPUT_STRING is not NULL it
584    will be fed to stdin of the process.  stderr is logged using
585    log_info and the process' stdout is returned in a newly malloced
586    buffer RESULT with the length stored at RESULTLEN if not given as
587    NULL.  A hidden Nul is appended to the output.  On error NULL is
588    stored at RESULT, a diagnostic is printed, and an error code
589    returned.  */
590 gpg_error_t
591 gnupg_exec_tool (const char *pgmname, const char *argv[],
592                  const char *input_string,
593                  char **result, size_t *resultlen)
594 {
595   gpg_error_t err;
596   estream_t input = NULL;
597   estream_t output;
598   size_t len;
599   size_t nread;
600
601   *result = NULL;
602   if (resultlen)
603     *resultlen = 0;
604
605   if (input_string)
606     {
607       len = strlen (input_string);
608       input = es_mopen ((char *) input_string, len, len,
609                         0 /* don't grow */, NULL, nop_free, "rb");
610       if (! input)
611         return my_error_from_syserror ();
612     }
613
614   output = es_fopenmem (0, "wb");
615   if (! output)
616     {
617       err = my_error_from_syserror ();
618       goto leave;
619     }
620
621   err = gnupg_exec_tool_stream (pgmname, argv, input, NULL, output, NULL, NULL);
622   if (err)
623     goto leave;
624
625   len = es_ftello (output);
626   err = es_fseek (output, 0, SEEK_SET);
627   if (err)
628     goto leave;
629
630   *result = xtrymalloc (len + 1);
631   if (!*result)
632     {
633       err = my_error_from_syserror ();
634       goto leave;
635     }
636
637   if (len)
638     {
639       if (es_read (output, *result, len, &nread))
640         {
641           err = my_error_from_syserror ();
642           goto leave;
643         }
644       if (nread != len)
645         log_fatal ("%s: short read from memstream\n", __func__);
646     }
647   (*result)[len] = 0;
648
649   if (resultlen)
650     *resultlen = len;
651
652  leave:
653   es_fclose (input);
654   es_fclose (output);
655   if (err)
656     {
657       xfree (*result);
658       *result = NULL;
659     }
660   return err;
661 }