Re-indented.
[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 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   FILE *fp = NULL;
53   static off_t count = 0;
54   int rc = 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       fflush (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           sprintf (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.outfile)
90     {
91       fname = xmalloc (strlen (opt.outfile) + 1);
92       strcpy (fname, opt.outfile);
93     }
94   else if (pt->namelen == 8 && !memcmp (pt->name, "_CONSOLE", 8))
95     {
96       log_info (_("data not saved; use option \"--output\" to save it\n"));
97       nooutput = 1;
98     }
99   else if (!opt.flags.use_embedded_filename)
100     {
101       fname = make_outfile_name (iobuf_get_real_fname (pt->buf));
102       if (!fname)
103         fname = ask_outfile_name (pt->name, pt->namelen);
104       if (!fname)
105         {
106           rc = gpg_error (GPG_ERR_GENERAL);     /* Can't create file. */
107           goto leave;
108         }
109     }
110   else
111     fname = utf8_to_native (pt->name, pt->namelen, 0);
112
113   if (nooutput)
114     ;
115   else if (iobuf_is_pipe_filename (fname) || !*fname)
116     {
117       /* No filename or "-" given; write to stdout. */
118       fp = stdout;
119 #ifdef HAVE_DOSISH_SYSTEM
120       setmode (fileno (fp), O_BINARY);
121 #endif
122     }
123   else
124     {
125       while (!overwrite_filep (fname))
126         {
127           char *tmp = ask_outfile_name (NULL, 0);
128           if (!tmp || !*tmp)
129             {
130               xfree (tmp);
131               /* FIXME: Below used to be G10ERR_CREATE_FILE */
132               rc = gpg_error (GPG_ERR_GENERAL); 
133               goto leave;
134             }
135           xfree (fname);
136           fname = tmp;
137         }
138     }
139   
140 #ifndef __riscos__
141   if (fp || nooutput)
142     ;
143   else if (is_secured_filename (fname))
144     {
145       errno = EPERM;
146       rc = gpg_error_from_syserror ();
147       log_error (_("error creating `%s': %s\n"), fname, strerror (errno));
148       goto leave;
149     }
150   else if (!(fp = fopen (fname, "wb")))
151     {
152       rc = gpg_error_from_syserror ();
153       log_error (_("error creating `%s': %s\n"), fname, strerror (errno));
154       goto leave;
155     }
156 #else /* __riscos__ */
157   /* If no output filename was given, i.e. we constructed it,
158      convert all '.' in fname to '/' but not vice versa as
159      we don't create directories! */
160   if (!opt.outfile)
161     for (c = 0; fname[c]; ++c)
162       if (fname[c] == '.')
163         fname[c] = '/';
164
165   if (fp || nooutput)
166     ;
167   else
168     {
169       fp = fopen (fname, "wb");
170       if (!fp)
171         {
172           log_error (_("error creating `%s': %s\n"), fname, strerror (errno));
173           rc = G10ERR_CREATE_FILE;
174           if (errno == 106)
175             log_info ("Do output file and input file have the same name?\n");
176           goto leave;
177         }
178
179       /* If there's a ,xxx extension in the embedded filename,
180          use that, else check whether the user input (in fname)
181          has a ,xxx appended, then use that in preference */
182       if ((c = riscos_get_filetype_from_string (pt->name, pt->namelen)) != -1)
183         filetype = c;
184       if ((c = riscos_get_filetype_from_string (fname, strlen (fname))) != -1)
185         filetype = c;
186       riscos_set_filetype_by_number (fname, filetype);
187     }
188 #endif /* __riscos__ */
189
190   if (!pt->is_partial)
191     {
192       /* We have an actual length (which might be zero). */
193
194       if (clearsig)
195         {
196           log_error ("clearsig encountered while not expected\n");
197           rc = G10ERR_UNEXPECTED;
198           goto leave;
199         }
200
201       if (convert) /* Text mode.  */
202         {
203           for (; pt->len; pt->len--)
204             {
205               if ((c = iobuf_get (pt->buf)) == -1)
206                 {
207                   rc = gpg_error_from_syserror ();
208                   log_error ("problem reading source (%u bytes remaining)\n",
209                              (unsigned) pt->len);
210                   goto leave;
211                 }
212               if (mfx->md)
213                 gcry_md_putc (mfx->md, c);
214 #ifndef HAVE_DOSISH_SYSTEM
215               if (c == '\r')    /* convert to native line ending */
216                 continue;       /* fixme: this hack might be too simple */
217 #endif
218               if (fp)
219                 {
220                   if (opt.max_output && (++count) > opt.max_output)
221                     {
222                       log_error ("error writing to `%s': %s\n",
223                                  fname, "exceeded --max-output limit\n");
224                       rc = gpg_error (GPG_ERR_TOO_LARGE);
225                       goto leave;
226                     }
227                   else if (putc (c, fp) == EOF)
228                     {
229                       if (ferror (fp))
230                         rc = gpg_error_from_syserror ();
231                       else
232                         rc = gpg_error (GPG_ERR_EOF);
233                       log_error ("error writing to `%s': %s\n",
234                                  fname, strerror (errno));
235                       goto leave;
236                     }
237                 }
238             }
239         }
240       else  /* Binary mode.  */
241         {
242           byte *buffer = xmalloc (32768);
243           while (pt->len)
244             {
245               int len = pt->len > 32768 ? 32768 : pt->len;
246               len = iobuf_read (pt->buf, buffer, len);
247               if (len == -1)
248                 {
249                   rc = gpg_error_from_syserror ();
250                   log_error ("problem reading source (%u bytes remaining)\n",
251                              (unsigned) pt->len);
252                   xfree (buffer);
253                   goto leave;
254                 }
255               if (mfx->md)
256                 gcry_md_write (mfx->md, buffer, len);
257               if (fp)
258                 {
259                   if (opt.max_output && (count += len) > opt.max_output)
260                     {
261                       log_error ("error writing to `%s': %s\n",
262                                  fname, "exceeded --max-output limit\n");
263                       rc = gpg_error (GPG_ERR_TOO_LARGE);
264                       xfree (buffer);
265                       goto leave;
266                     }
267                   else if (fwrite (buffer, 1, len, fp) != len)
268                     {
269                       rc = gpg_error_from_syserror ();
270                       log_error ("error writing to `%s': %s\n",
271                                  fname, strerror (errno));
272                       xfree (buffer);
273                       goto leave;
274                     }
275                 }
276               pt->len -= len;
277             }
278           xfree (buffer);
279         }
280     }
281   else if (!clearsig)
282     {
283       if (convert)
284         {                       /* text mode */
285           while ((c = iobuf_get (pt->buf)) != -1)
286             {
287               if (mfx->md)
288                 gcry_md_putc (mfx->md, c);
289 #ifndef HAVE_DOSISH_SYSTEM
290               if (convert && c == '\r')
291                 continue;       /* fixme: this hack might be too simple */
292 #endif
293               if (fp)
294                 {
295                   if (opt.max_output && (++count) > opt.max_output)
296                     {
297                       log_error ("Error writing to `%s': %s\n",
298                                  fname, "exceeded --max-output limit\n");
299                       rc = gpg_error (GPG_ERR_TOO_LARGE);
300                       goto leave;
301                     }
302                   else if (putc (c, fp) == EOF)
303                     {
304                       if (ferror (fp))
305                         rc = gpg_error_from_syserror ();
306                       else
307                         rc = gpg_error (GPG_ERR_EOF);
308                       log_error ("error writing to `%s': %s\n",
309                                  fname, strerror (errno));
310                       goto leave;
311                     }
312                 }
313             }
314         }
315       else
316         {                       /* binary mode */
317           byte *buffer = xmalloc (32768);
318           int eof_seen = 0;
319
320           while (!eof_seen)
321             {
322               /* Why do we check for len < 32768:
323                * If we won't, we would practically read 2 EOFs but
324                * the first one has already popped the block_filter
325                * off and therefore we don't catch the boundary.
326                * So, always assume EOF if iobuf_read returns less bytes
327                * then requested */
328               int len = iobuf_read (pt->buf, buffer, 32768);
329               if (len == -1)
330                 break;
331               if (len < 32768)
332                 eof_seen = 1;
333               if (mfx->md)
334                 gcry_md_write (mfx->md, buffer, len);
335               if (fp)
336                 {
337                   if (opt.max_output && (count += len) > opt.max_output)
338                     {
339                       log_error ("error writing to `%s': %s\n",
340                                  fname, "exceeded --max-output limit\n");
341                       rc = gpg_error (GPG_ERR_TOO_LARGE);
342                       xfree (buffer);
343                       goto leave;
344                     }
345                   else if (fwrite (buffer, 1, len, fp) != len)
346                     {
347                       rc = (errno ? gpg_error_from_syserror ()
348                             : gpg_error (GPG_ERR_INTERNAL));
349                       log_error ("error writing to `%s': %s\n",
350                                  fname, strerror (errno));
351                       xfree (buffer);
352                       goto leave;
353                     }
354                 }
355             }
356           xfree (buffer);
357         }
358       pt->buf = NULL;
359     }
360   else /* Clear text signature - don't hash the last CR,LF.   */
361     { 
362       int state = 0;
363
364       while ((c = iobuf_get (pt->buf)) != -1)
365         {
366           if (fp)
367             {
368               if (opt.max_output && (++count) > opt.max_output)
369                 {
370                   log_error ("error writing to `%s': %s\n",
371                              fname, "exceeded --max-output limit\n");
372                   rc = gpg_error (GPG_ERR_TOO_LARGE);
373                   goto leave;
374                 }
375               else if (putc (c, fp) == EOF)
376                 {
377                   rc = (errno ? gpg_error_from_syserror ()
378                         : gpg_error (GPG_ERR_INTERNAL));
379                   log_error ("error writing to `%s': %s\n",
380                              fname, strerror (errno));
381                   goto leave;
382                 }
383             }
384           if (!mfx->md)
385             continue;
386           if (state == 2)
387             {
388               gcry_md_putc (mfx->md, '\r');
389               gcry_md_putc (mfx->md, '\n');
390               state = 0;
391             }
392           if (!state)
393             {
394               if (c == '\r')
395                 state = 1;
396               else if (c == '\n')
397                 state = 2;
398               else
399                 gcry_md_putc (mfx->md, c);
400             }
401           else if (state == 1)
402             {
403               if (c == '\n')
404                 state = 2;
405               else
406                 {
407                   gcry_md_putc (mfx->md, '\r');
408                   if (c == '\r')
409                     state = 1;
410                   else
411                     {
412                       state = 0;
413                       gcry_md_putc (mfx->md, c);
414                     }
415                 }
416             }
417         }
418       pt->buf = NULL;
419     }
420
421   if (fp && fp != stdout && fclose (fp))
422     {
423       rc = (errno ? gpg_error_from_syserror ()
424             : gpg_error (GPG_ERR_INTERNAL));
425       log_error ("error closing `%s': %s\n", fname, strerror (errno));
426       fp = NULL;
427       goto leave;
428     }
429   fp = NULL;
430
431  leave:
432   /* Make sure that stdout gets flushed after the plaintext has been
433      handled.  This is for extra security as we do a flush anyway
434      before checking the signature.  */
435   fflush (stdout);
436
437   if (fp && fp != stdout)
438     fclose (fp);
439   xfree (fname);
440   return rc;
441 }
442
443
444 static void
445 do_hash (gcry_md_hd_t md, gcry_md_hd_t md2, IOBUF fp, int textmode)
446 {
447   text_filter_context_t tfx;
448   int c;
449
450   if (textmode)
451     {
452       memset (&tfx, 0, sizeof tfx);
453       iobuf_push_filter (fp, text_filter, &tfx);
454     }
455   if (md2)
456     {                           /* work around a strange behaviour in pgp2 */
457       /* It seems that at least PGP5 converts a single CR to a CR,LF too */
458       int lc = -1;
459       while ((c = iobuf_get (fp)) != -1)
460         {
461           if (c == '\n' && lc == '\r')
462             gcry_md_putc (md2, c);
463           else if (c == '\n')
464             {
465               gcry_md_putc (md2, '\r');
466               gcry_md_putc (md2, c);
467             }
468           else if (c != '\n' && lc == '\r')
469             {
470               gcry_md_putc (md2, '\n');
471               gcry_md_putc (md2, c);
472             }
473           else
474             gcry_md_putc (md2, c);
475
476           if (md)
477             gcry_md_putc (md, c);
478           lc = c;
479         }
480     }
481   else
482     {
483       while ((c = iobuf_get (fp)) != -1)
484         {
485           if (md)
486             gcry_md_putc (md, c);
487         }
488     }
489 }
490
491
492 /****************
493  * Ask for the detached datafile and calculate the digest from it.
494  * INFILE is the name of the input file.
495  */
496 int
497 ask_for_detached_datafile (gcry_md_hd_t md, gcry_md_hd_t md2,
498                            const char *inname, int textmode)
499 {
500   progress_filter_context_t *pfx;
501   char *answer = NULL;
502   IOBUF fp;
503   int rc = 0;
504
505   pfx = new_progress_context ();
506   fp = open_sigfile (inname, pfx);      /* Open default file. */
507
508   if (!fp && !opt.batch)
509     {
510       int any = 0;
511       tty_printf (_("Detached signature.\n"));
512       do
513         {
514           char *name;
515
516           xfree (answer);
517           tty_enable_completion (NULL);
518           name = cpr_get ("detached_signature.filename",
519                           _("Please enter name of data file: "));
520           tty_disable_completion ();
521           cpr_kill_prompt ();
522           answer = make_filename (name, (void *) NULL);
523           xfree (name);
524
525           if (any && !*answer)
526             {
527               rc = gpg_error (GPG_ERR_GENERAL); /*G10ERR_READ_FILE */
528               goto leave;
529             }
530           fp = iobuf_open (answer);
531           if (fp && is_secured_file (iobuf_get_fd (fp)))
532             {
533               iobuf_close (fp);
534               fp = NULL;
535               errno = EPERM;
536             }
537           if (!fp && errno == ENOENT)
538             {
539               tty_printf ("No such file, try again or hit enter to quit.\n");
540               any++;
541             }
542           else if (!fp)
543             {
544               rc = gpg_error_from_syserror ();
545               log_error (_("can't open `%s': %s\n"), answer,
546                          strerror (errno));
547               goto leave;
548             }
549         }
550       while (!fp);
551     }
552
553   if (!fp)
554     {
555       if (opt.verbose)
556         log_info (_("reading stdin ...\n"));
557       fp = iobuf_open (NULL);
558       assert (fp);
559     }
560   do_hash (md, md2, fp, textmode);
561   iobuf_close (fp);
562
563 leave:
564   xfree (answer);
565   release_progress_context (pfx);
566   return rc;
567 }
568
569
570
571 /****************
572  * Hash the given files and append the hash to hash context md.
573  * If FILES is NULL, hash stdin.
574  */
575 int
576 hash_datafiles (gcry_md_hd_t md, gcry_md_hd_t md2, strlist_t files,
577                 const char *sigfilename, int textmode)
578 {
579   progress_filter_context_t *pfx;
580   IOBUF fp;
581   strlist_t sl;
582
583   pfx = new_progress_context ();
584
585   if (!files)
586     {
587       /* check whether we can open the signed material */
588       fp = open_sigfile (sigfilename, pfx);
589       if (fp)
590         {
591           do_hash (md, md2, fp, textmode);
592           iobuf_close (fp);
593           release_progress_context (pfx);
594           return 0;
595         }
596       log_error (_("no signed data\n"));
597       release_progress_context (pfx);
598       return gpg_error (GPG_ERR_NO_DATA);
599     }
600
601
602   for (sl = files; sl; sl = sl->next)
603     {
604       fp = iobuf_open (sl->d);
605       if (fp && is_secured_file (iobuf_get_fd (fp)))
606         {
607           iobuf_close (fp);
608           fp = NULL;
609           errno = EPERM;
610         }
611       if (!fp)
612         {
613           int rc = gpg_error_from_syserror ();
614           log_error (_("can't open signed data `%s'\n"),
615                      print_fname_stdin (sl->d));
616           release_progress_context (pfx);
617           return rc;
618         }
619       handle_progress (pfx, fp, sl->d);
620       do_hash (md, md2, fp, textmode);
621       iobuf_close (fp);
622     }
623
624   release_progress_context (pfx);
625   return 0;
626 }
627
628
629 /* Hash the data from file descriptor DATA_FD and append the hash to hash
630    contexts MD and MD2.  */
631 int
632 hash_datafile_by_fd (gcry_md_hd_t md, gcry_md_hd_t md2, int data_fd,
633                      int textmode)
634 {
635   progress_filter_context_t *pfx = new_progress_context ();
636   iobuf_t fp;
637
638   fp = iobuf_fdopen (data_fd, "rb");
639   if (fp && is_secured_file (data_fd))
640     {
641       iobuf_close (fp);
642       fp = NULL;
643       errno = EPERM;
644     }
645   if (!fp)
646     {
647       int rc = gpg_error_from_syserror ();
648       log_error (_("can't open signed data fd=%d: %s\n"),
649                  data_fd, strerror (errno));
650       release_progress_context (pfx);
651       return rc;
652     }
653
654   handle_progress (pfx, fp, NULL);
655
656   do_hash (md, md2, fp, textmode);
657
658   iobuf_close (fp);
659
660   release_progress_context (pfx);
661   return 0;
662 }
663
664
665 /* Set up a plaintext packet with the appropriate filename.  If there
666    is a --set-filename, use it (it's already UTF8).  If there is a
667    regular filename, UTF8-ize it if necessary.  If there is no
668    filenames at all, set the field empty. */
669
670 PKT_plaintext *
671 setup_plaintext_name (const char *filename, IOBUF iobuf)
672 {
673   PKT_plaintext *pt;
674
675   if (filename || opt.set_filename)
676     {
677       char *s;
678
679       if (opt.set_filename)
680         s = make_basename (opt.set_filename, iobuf_get_real_fname (iobuf));
681       else if (filename && !opt.flags.utf8_filename)
682         {
683           char *tmp = native_to_utf8 (filename);
684           s = make_basename (tmp, iobuf_get_real_fname (iobuf));
685           xfree (tmp);
686         }
687       else
688         s = make_basename (filename, iobuf_get_real_fname (iobuf));
689
690       pt = xmalloc (sizeof *pt + strlen (s) - 1);
691       pt->namelen = strlen (s);
692       memcpy (pt->name, s, pt->namelen);
693       xfree (s);
694     }
695   else
696     {
697       /* no filename */
698       pt = xmalloc (sizeof *pt - 1);
699       pt->namelen = 0;
700     }
701
702   return pt;
703 }