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