gpg: Improve 'General key info' line of --card-status.
[gnupg.git] / g10 / plaintext.c
1 /* plaintext.c -  process plaintext packets
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2009, 2010 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27 #include <sys/types.h>
28 #ifdef HAVE_DOSISH_SYSTEM
29 # include <fcntl.h> /* for setmode() */
30 #endif
31
32 #include "gpg.h"
33 #include "util.h"
34 #include "options.h"
35 #include "packet.h"
36 #include "ttyio.h"
37 #include "filter.h"
38 #include "main.h"
39 #include "status.h"
40 #include "i18n.h"
41
42
43 /* Handle a plaintext packet.  If MFX is not NULL, update the MDs
44  * Note: We should have used the filter stuff here, but we have to add
45  * some easy mimic to set a read limit, so we calculate only the bytes
46  * from the plaintext.  */
47 int
48 handle_plaintext (PKT_plaintext * pt, md_filter_context_t * mfx,
49                   int nooutput, int clearsig)
50 {
51   char *fname = NULL;
52   estream_t fp = NULL;
53   static off_t count = 0;
54   int err = 0;
55   int c;
56   int convert = (pt->mode == 't' || pt->mode == 'u');
57 #ifdef __riscos__
58   int filetype = 0xfff;
59 #endif
60
61   /* Let people know what the plaintext info is. This allows the
62      receiving program to try and do something different based on the
63      format code (say, recode UTF-8 to local). */
64   if (!nooutput && is_status_enabled ())
65     {
66       char status[50];
67
68       /* Better make sure that stdout has been flushed in case the
69          output will be written to it.  This is to make sure that no
70          not-yet-flushed stuff will be written after the plaintext
71          status message.  */
72       es_fflush (es_stdout);
73
74       snprintf (status, sizeof status,
75                 "%X %lu ", (byte) pt->mode, (ulong) pt->timestamp);
76       write_status_text_and_buffer (STATUS_PLAINTEXT,
77                                     status, pt->name, pt->namelen, 0);
78
79       if (!pt->is_partial)
80         {
81           snprintf (status, sizeof status, "%lu", (ulong) pt->len);
82           write_status_text (STATUS_PLAINTEXT_LENGTH, status);
83         }
84     }
85
86   /* Create the filename as C string.  */
87   if (nooutput)
88     ;
89   else if (opt.outfp)
90     {
91       fname = xtrystrdup ("[FP]");
92       if (!fname)
93         {
94           err = gpg_error_from_syserror ();
95           goto leave;
96         }
97     }
98   else if (opt.outfile)
99     {
100       fname = xtrystrdup (opt.outfile);
101       if (!fname)
102         {
103           err = gpg_error_from_syserror ();
104           goto leave;
105         }
106     }
107   else if (pt->namelen == 8 && !memcmp (pt->name, "_CONSOLE", 8))
108     {
109       log_info (_("data not saved; use option \"--output\" to save it\n"));
110       nooutput = 1;
111     }
112   else if (!opt.flags.use_embedded_filename)
113     {
114       fname = make_outfile_name (iobuf_get_real_fname (pt->buf));
115       if (!fname)
116         fname = ask_outfile_name (pt->name, pt->namelen);
117       if (!fname)
118         {
119           err = gpg_error (GPG_ERR_GENERAL);    /* Can't create file. */
120           goto leave;
121         }
122     }
123   else
124     fname = utf8_to_native (pt->name, pt->namelen, 0);
125
126   if (nooutput)
127     ;
128   else if (opt.outfp)
129     {
130       fp = opt.outfp;
131       es_set_binary (fp);
132     }
133   else if (iobuf_is_pipe_filename (fname) || !*fname)
134     {
135       /* No filename or "-" given; write to stdout. */
136       fp = es_stdout;
137       es_set_binary (fp);
138     }
139   else
140     {
141       while (!overwrite_filep (fname))
142         {
143           char *tmp = ask_outfile_name (NULL, 0);
144           if (!tmp || !*tmp)
145             {
146               xfree (tmp);
147               /* FIXME: Below used to be GPG_ERR_CREATE_FILE */
148               err = gpg_error (GPG_ERR_GENERAL);
149               goto leave;
150             }
151           xfree (fname);
152           fname = tmp;
153         }
154     }
155
156 #ifndef __riscos__
157   if (opt.outfp && is_secured_file (es_fileno (opt.outfp)))
158     {
159       err = gpg_error (GPG_ERR_EPERM);
160       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
161       goto leave;
162     }
163   else if (fp || nooutput)
164     ;
165   else if (is_secured_filename (fname))
166     {
167       gpg_err_set_errno (EPERM);
168       err = gpg_error_from_syserror ();
169       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
170       goto leave;
171     }
172   else if (!(fp = es_fopen (fname, "wb")))
173     {
174       err = gpg_error_from_syserror ();
175       log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
176       goto leave;
177     }
178 #else /* __riscos__ */
179   /* If no output filename was given, i.e. we constructed it, convert
180      all '.' in fname to '/' but not vice versa as we don't create
181      directories! */
182   if (!opt.outfile)
183     for (c = 0; fname[c]; ++c)
184       if (fname[c] == '.')
185         fname[c] = '/';
186
187   if (fp || nooutput)
188     ;
189   else
190     {
191       /* Note: riscos stuff is not expected to wrok anymore.  If we
192          want to port it again to riscos we should do most of the suff
193          in estream.  FIXME: Consider to remove all riscos special
194          cases.  */
195       fp = fopen (fname, "wb");
196       if (!fp)
197         {
198           log_error (_("error creating '%s': %s\n"), fname, gpg_strerror (err));
199           err = GPG_ERR_CREATE_FILE;
200           if (errno == 106)
201             log_info ("Do output file and input file have the same name?\n");
202           goto leave;
203         }
204
205       /* If there's a ,xxx extension in the embedded filename,
206          use that, else check whether the user input (in fname)
207          has a ,xxx appended, then use that in preference */
208       if ((c = riscos_get_filetype_from_string (pt->name, pt->namelen)) != -1)
209         filetype = c;
210       if ((c = riscos_get_filetype_from_string (fname, strlen (fname))) != -1)
211         filetype = c;
212       riscos_set_filetype_by_number (fname, filetype);
213     }
214 #endif /* __riscos__ */
215
216   if (!pt->is_partial)
217     {
218       /* We have an actual length (which might be zero). */
219
220       if (clearsig)
221         {
222           log_error ("clearsig encountered while not expected\n");
223           err = gpg_error (GPG_ERR_UNEXPECTED);
224           goto leave;
225         }
226
227       if (convert) /* Text mode.  */
228         {
229           for (; pt->len; pt->len--)
230             {
231               if ((c = iobuf_get (pt->buf)) == -1)
232                 {
233                   err = gpg_error_from_syserror ();
234                   log_error ("problem reading source (%u bytes remaining)\n",
235                              (unsigned) pt->len);
236                   goto leave;
237                 }
238               if (mfx->md)
239                 gcry_md_putc (mfx->md, c);
240 #ifndef HAVE_DOSISH_SYSTEM
241               if (c == '\r')    /* convert to native line ending */
242                 continue;       /* fixme: this hack might be too simple */
243 #endif
244               if (fp)
245                 {
246                   if (opt.max_output && (++count) > opt.max_output)
247                     {
248                       log_error ("error writing to '%s': %s\n",
249                                  fname, "exceeded --max-output limit\n");
250                       err = gpg_error (GPG_ERR_TOO_LARGE);
251                       goto leave;
252                     }
253                   else if (es_putc (c, fp) == EOF)
254                     {
255                       if (es_ferror (fp))
256                         err = gpg_error_from_syserror ();
257                       else
258                         err = gpg_error (GPG_ERR_EOF);
259                       log_error ("error writing to '%s': %s\n",
260                                  fname, gpg_strerror (err));
261                       goto leave;
262                     }
263                 }
264             }
265         }
266       else  /* Binary mode.  */
267         {
268           byte *buffer = xmalloc (32768);
269           while (pt->len)
270             {
271               int len = pt->len > 32768 ? 32768 : pt->len;
272               len = iobuf_read (pt->buf, buffer, len);
273               if (len == -1)
274                 {
275                   err = gpg_error_from_syserror ();
276                   log_error ("problem reading source (%u bytes remaining)\n",
277                              (unsigned) pt->len);
278                   xfree (buffer);
279                   goto leave;
280                 }
281               if (mfx->md)
282                 gcry_md_write (mfx->md, buffer, len);
283               if (fp)
284                 {
285                   if (opt.max_output && (count += len) > opt.max_output)
286                     {
287                       log_error ("error writing to '%s': %s\n",
288                                  fname, "exceeded --max-output limit\n");
289                       err = gpg_error (GPG_ERR_TOO_LARGE);
290                       xfree (buffer);
291                       goto leave;
292                     }
293                   else if (es_fwrite (buffer, 1, len, fp) != len)
294                     {
295                       err = gpg_error_from_syserror ();
296                       log_error ("error writing to '%s': %s\n",
297                                  fname, gpg_strerror (err));
298                       xfree (buffer);
299                       goto leave;
300                     }
301                 }
302               pt->len -= len;
303             }
304           xfree (buffer);
305         }
306     }
307   else if (!clearsig)
308     {
309       if (convert)
310         {                       /* text mode */
311           while ((c = iobuf_get (pt->buf)) != -1)
312             {
313               if (mfx->md)
314                 gcry_md_putc (mfx->md, c);
315 #ifndef HAVE_DOSISH_SYSTEM
316               if (convert && c == '\r')
317                 continue;       /* fixme: this hack might be too simple */
318 #endif
319               if (fp)
320                 {
321                   if (opt.max_output && (++count) > opt.max_output)
322                     {
323                       log_error ("Error writing to '%s': %s\n",
324                                  fname, "exceeded --max-output limit\n");
325                       err = gpg_error (GPG_ERR_TOO_LARGE);
326                       goto leave;
327                     }
328                   else if (es_putc (c, fp) == EOF)
329                     {
330                       if (es_ferror (fp))
331                         err = gpg_error_from_syserror ();
332                       else
333                         err = gpg_error (GPG_ERR_EOF);
334                       log_error ("error writing to '%s': %s\n",
335                                  fname, gpg_strerror (err));
336                       goto leave;
337                     }
338                 }
339             }
340         }
341       else
342         {                       /* binary mode */
343           byte *buffer;
344           int eof_seen = 0;
345
346           buffer = xtrymalloc (32768);
347           if (!buffer)
348             {
349               err = gpg_error_from_syserror ();
350               goto leave;
351             }
352
353           while (!eof_seen)
354             {
355               /* Why do we check for len < 32768:
356                * If we won't, we would practically read 2 EOFs but
357                * the first one has already popped the block_filter
358                * off and therefore we don't catch the boundary.
359                * So, always assume EOF if iobuf_read returns less bytes
360                * then requested */
361               int len = iobuf_read (pt->buf, buffer, 32768);
362               if (len == -1)
363                 break;
364               if (len < 32768)
365                 eof_seen = 1;
366               if (mfx->md)
367                 gcry_md_write (mfx->md, buffer, len);
368               if (fp)
369                 {
370                   if (opt.max_output && (count += len) > opt.max_output)
371                     {
372                       log_error ("error writing to '%s': %s\n",
373                                  fname, "exceeded --max-output limit\n");
374                       err = gpg_error (GPG_ERR_TOO_LARGE);
375                       xfree (buffer);
376                       goto leave;
377                     }
378                   else if (es_fwrite (buffer, 1, len, fp) != len)
379                     {
380                       err = gpg_error_from_syserror ();
381                       log_error ("error writing to '%s': %s\n",
382                                  fname, gpg_strerror (err));
383                       xfree (buffer);
384                       goto leave;
385                     }
386                 }
387             }
388           xfree (buffer);
389         }
390       pt->buf = NULL;
391     }
392   else /* Clear text signature - don't hash the last CR,LF.   */
393     {
394       int state = 0;
395
396       while ((c = iobuf_get (pt->buf)) != -1)
397         {
398           if (fp)
399             {
400               if (opt.max_output && (++count) > opt.max_output)
401                 {
402                   log_error ("error writing to '%s': %s\n",
403                              fname, "exceeded --max-output limit\n");
404                   err = gpg_error (GPG_ERR_TOO_LARGE);
405                   goto leave;
406                 }
407               else if (es_putc (c, fp) == EOF)
408                 {
409                   err = gpg_error_from_syserror ();
410                   log_error ("error writing to '%s': %s\n",
411                              fname, gpg_strerror (err));
412                   goto leave;
413                 }
414             }
415           if (!mfx->md)
416             continue;
417           if (state == 2)
418             {
419               gcry_md_putc (mfx->md, '\r');
420               gcry_md_putc (mfx->md, '\n');
421               state = 0;
422             }
423           if (!state)
424             {
425               if (c == '\r')
426                 state = 1;
427               else if (c == '\n')
428                 state = 2;
429               else
430                 gcry_md_putc (mfx->md, c);
431             }
432           else if (state == 1)
433             {
434               if (c == '\n')
435                 state = 2;
436               else
437                 {
438                   gcry_md_putc (mfx->md, '\r');
439                   if (c == '\r')
440                     state = 1;
441                   else
442                     {
443                       state = 0;
444                       gcry_md_putc (mfx->md, c);
445                     }
446                 }
447             }
448         }
449       pt->buf = NULL;
450     }
451
452   if (fp && fp != es_stdout && fp != opt.outfp && es_fclose (fp))
453     {
454       err = gpg_error_from_syserror ();
455       log_error ("error closing '%s': %s\n", fname, gpg_strerror (err));
456       fp = NULL;
457       goto leave;
458     }
459   fp = NULL;
460
461  leave:
462   /* Make sure that stdout gets flushed after the plaintext has been
463      handled.  This is for extra security as we do a flush anyway
464      before checking the signature.  */
465   if (es_fflush (es_stdout))
466     {
467       /* We need to check the return code to detect errors like disk
468          full for short plaintexts.  See bug#1207.  Checking return
469          values is a good idea in any case.  */
470       if (!err)
471         err = gpg_error_from_syserror ();
472       log_error ("error flushing '%s': %s\n", "[stdout]",
473                  gpg_strerror (err));
474     }
475
476   if (fp && fp != es_stdout && fp != opt.outfp)
477     es_fclose (fp);
478   xfree (fname);
479   return err;
480 }
481
482
483 static void
484 do_hash (gcry_md_hd_t md, gcry_md_hd_t md2, IOBUF fp, int textmode)
485 {
486   text_filter_context_t tfx;
487   int c;
488
489   if (textmode)
490     {
491       memset (&tfx, 0, sizeof tfx);
492       iobuf_push_filter (fp, text_filter, &tfx);
493     }
494   if (md2)
495     {                           /* work around a strange behaviour in pgp2 */
496       /* It seems that at least PGP5 converts a single CR to a CR,LF too */
497       int lc = -1;
498       while ((c = iobuf_get (fp)) != -1)
499         {
500           if (c == '\n' && lc == '\r')
501             gcry_md_putc (md2, c);
502           else if (c == '\n')
503             {
504               gcry_md_putc (md2, '\r');
505               gcry_md_putc (md2, c);
506             }
507           else if (c != '\n' && lc == '\r')
508             {
509               gcry_md_putc (md2, '\n');
510               gcry_md_putc (md2, c);
511             }
512           else
513             gcry_md_putc (md2, c);
514
515           if (md)
516             gcry_md_putc (md, c);
517           lc = c;
518         }
519     }
520   else
521     {
522       while ((c = iobuf_get (fp)) != -1)
523         {
524           if (md)
525             gcry_md_putc (md, c);
526         }
527     }
528 }
529
530
531 /****************
532  * Ask for the detached datafile and calculate the digest from it.
533  * INFILE is the name of the input file.
534  */
535 int
536 ask_for_detached_datafile (gcry_md_hd_t md, gcry_md_hd_t md2,
537                            const char *inname, int textmode)
538 {
539   progress_filter_context_t *pfx;
540   char *answer = NULL;
541   IOBUF fp;
542   int rc = 0;
543
544   pfx = new_progress_context ();
545   fp = open_sigfile (inname, pfx);      /* Open default file. */
546
547   if (!fp && !opt.batch)
548     {
549       int any = 0;
550       tty_printf (_("Detached signature.\n"));
551       do
552         {
553           char *name;
554
555           xfree (answer);
556           tty_enable_completion (NULL);
557           name = cpr_get ("detached_signature.filename",
558                           _("Please enter name of data file: "));
559           tty_disable_completion ();
560           cpr_kill_prompt ();
561           answer = make_filename (name, (void *) NULL);
562           xfree (name);
563
564           if (any && !*answer)
565             {
566               rc = gpg_error (GPG_ERR_GENERAL); /*G10ERR_READ_FILE */
567               goto leave;
568             }
569           fp = iobuf_open (answer);
570           if (fp && is_secured_file (iobuf_get_fd (fp)))
571             {
572               iobuf_close (fp);
573               fp = NULL;
574               gpg_err_set_errno (EPERM);
575             }
576           if (!fp && errno == ENOENT)
577             {
578               tty_printf ("No such file, try again or hit enter to quit.\n");
579               any++;
580             }
581           else if (!fp)
582             {
583               rc = gpg_error_from_syserror ();
584               log_error (_("can't open '%s': %s\n"), answer,
585                          strerror (errno));
586               goto leave;
587             }
588         }
589       while (!fp);
590     }
591
592   if (!fp)
593     {
594       if (opt.verbose)
595         log_info (_("reading stdin ...\n"));
596       fp = iobuf_open (NULL);
597       assert (fp);
598     }
599   do_hash (md, md2, fp, textmode);
600   iobuf_close (fp);
601
602 leave:
603   xfree (answer);
604   release_progress_context (pfx);
605   return rc;
606 }
607
608
609
610 /* Hash the given files and append the hash to hash contexts MD and
611  * MD2.  If FILES is NULL, stdin is hashed.  */
612 int
613 hash_datafiles (gcry_md_hd_t md, gcry_md_hd_t md2, strlist_t files,
614                 const char *sigfilename, int textmode)
615 {
616   progress_filter_context_t *pfx;
617   IOBUF fp;
618   strlist_t sl;
619
620   pfx = new_progress_context ();
621
622   if (!files)
623     {
624       /* Check whether we can open the signed material.  We avoid
625          trying to open a file if run in batch mode.  This assumed
626          data file for a sig file feature is just a convenience thing
627          for the command line and the user needs to read possible
628          warning messages. */
629       if (!opt.batch)
630         {
631           fp = open_sigfile (sigfilename, pfx);
632           if (fp)
633             {
634               do_hash (md, md2, fp, textmode);
635               iobuf_close (fp);
636               release_progress_context (pfx);
637               return 0;
638             }
639         }
640       log_error (_("no signed data\n"));
641       release_progress_context (pfx);
642       return gpg_error (GPG_ERR_NO_DATA);
643     }
644
645
646   for (sl = files; sl; sl = sl->next)
647     {
648       fp = iobuf_open (sl->d);
649       if (fp && is_secured_file (iobuf_get_fd (fp)))
650         {
651           iobuf_close (fp);
652           fp = NULL;
653           gpg_err_set_errno (EPERM);
654         }
655       if (!fp)
656         {
657           int rc = gpg_error_from_syserror ();
658           log_error (_("can't open signed data '%s'\n"),
659                      print_fname_stdin (sl->d));
660           release_progress_context (pfx);
661           return rc;
662         }
663       handle_progress (pfx, fp, sl->d);
664       do_hash (md, md2, fp, textmode);
665       iobuf_close (fp);
666     }
667
668   release_progress_context (pfx);
669   return 0;
670 }
671
672
673 /* Hash the data from file descriptor DATA_FD and append the hash to hash
674    contexts MD and MD2.  */
675 int
676 hash_datafile_by_fd (gcry_md_hd_t md, gcry_md_hd_t md2, int data_fd,
677                      int textmode)
678 {
679   progress_filter_context_t *pfx = new_progress_context ();
680   iobuf_t fp;
681
682   if (is_secured_file (data_fd))
683     {
684       fp = NULL;
685       gpg_err_set_errno (EPERM);
686     }
687   else
688     fp = iobuf_fdopen_nc (data_fd, "rb");
689
690   if (!fp)
691     {
692       int rc = gpg_error_from_syserror ();
693       log_error (_("can't open signed data fd=%d: %s\n"),
694                  data_fd, strerror (errno));
695       release_progress_context (pfx);
696       return rc;
697     }
698
699   handle_progress (pfx, fp, NULL);
700
701   do_hash (md, md2, fp, textmode);
702
703   iobuf_close (fp);
704
705   release_progress_context (pfx);
706   return 0;
707 }
708
709
710 /* Set up a plaintext packet with the appropriate filename.  If there
711    is a --set-filename, use it (it's already UTF8).  If there is a
712    regular filename, UTF8-ize it if necessary.  If there is no
713    filenames at all, set the field empty. */
714
715 PKT_plaintext *
716 setup_plaintext_name (const char *filename, IOBUF iobuf)
717 {
718   PKT_plaintext *pt;
719
720   if ((filename && !iobuf_is_pipe_filename (filename))
721        || (opt.set_filename && !iobuf_is_pipe_filename (opt.set_filename)))
722     {
723       char *s;
724
725       if (opt.set_filename)
726         s = make_basename (opt.set_filename, iobuf_get_real_fname (iobuf));
727       else if (filename && !opt.flags.utf8_filename)
728         {
729           char *tmp = native_to_utf8 (filename);
730           s = make_basename (tmp, iobuf_get_real_fname (iobuf));
731           xfree (tmp);
732         }
733       else
734         s = make_basename (filename, iobuf_get_real_fname (iobuf));
735
736       pt = xmalloc (sizeof *pt + strlen (s) - 1);
737       pt->namelen = strlen (s);
738       memcpy (pt->name, s, pt->namelen);
739       xfree (s);
740     }
741   else
742     {
743       /* no filename */
744       pt = xmalloc (sizeof *pt - 1);
745       pt->namelen = 0;
746     }
747
748   return pt;
749 }