g10/plaintext.c

   1 /* plaintext.c -  process plaintext packets
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3  *               2005 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 2 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, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20  * USA.
  21  */
  22
  23 #include <config.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <assert.h>
  29 #include <sys/types.h>
  30 #ifdef HAVE_DOSISH_SYSTEM
  31 #include <fcntl.h> /* for setmode() */
  32 #endif
  33
  34 #include "util.h"
  35 #include "memory.h"
  36 #include "options.h"
  37 #include "packet.h"
  38 #include "ttyio.h"
  39 #include "filter.h"
  40 #include "main.h"
  41 #include "status.h"
  42 #include "i18n.h"
  43
  44
  45 /****************
  46  * Handle a plaintext packet.  If MFX is not NULL, update the MDs
  47  * Note: we should use the filter stuff here, but we have to add some
  48  *       easy mimic to set a read limit, so we calculate only the
  49  *       bytes from the plaintext.
  50  */
  51 int
  52 handle_plaintext( PKT_plaintext *pt, md_filter_context_t *mfx,
  53                   int nooutput, int clearsig )
  54 {
  55     char *fname = NULL;
  56     FILE *fp = NULL;
  57     static off_t count=0;
  58     int rc = 0;
  59     int c;
  60     int convert = (pt->mode == 't' || pt->mode == 'u');
  61 #ifdef __riscos__
  62     int filetype = 0xfff;
  63 #endif
  64
  65     /* Let people know what the plaintext info is. This allows the
  66        receiving program to try and do something different based on
  67        the format code (say, recode UTF-8 to local). */
  68     if(!nooutput && is_status_enabled())
  69       {
  70         char status[50];
  71
  72         sprintf(status,"%X %lu ",(byte)pt->mode,(ulong)pt->timestamp);
  73         write_status_text_and_buffer(STATUS_PLAINTEXT,
  74                                      status,pt->name,pt->namelen,0);
  75
  76         if(!pt->is_partial)
  77           {
  78             sprintf(status,"%lu",(ulong)pt->len);
  79             write_status_text(STATUS_PLAINTEXT_LENGTH,status);
  80           }
  81       }
  82
  83     /* create the filename as C string */
  84     if( nooutput )
  85         ;
  86     else if( opt.outfile ) {
  87         fname = xmalloc( strlen( opt.outfile ) + 1);
  88         strcpy(fname, opt.outfile );
  89     }
  90     else if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) ) {
  91         log_info(_("data not saved; use option \"--output\" to save it\n"));
  92         nooutput = 1;
  93     }
  94     else if( !opt.use_embedded_filename ) {
  95         fname = make_outfile_name( iobuf_get_real_fname(pt->buf) );
  96         if( !fname )
  97             fname = ask_outfile_name( pt->name, pt->namelen );
  98         if( !fname ) {
  99             rc = G10ERR_CREATE_FILE;
 100             goto leave;
 101         }
 102     }
 103     else {
 104         fname = make_printable_string( pt->name, pt->namelen, 0 );
 105     }
 106
 107     if( nooutput )
 108         ;
 109     else if ( iobuf_is_pipe_filename (fname) || !*fname)
 110       {
 111         /* No filename or "-" given; write to stdout. */
 112         fp = stdout;
 113 #ifdef HAVE_DOSISH_SYSTEM
 114         setmode ( fileno(fp) , O_BINARY );
 115 #endif
 116       }
 117     else {
 118         while( !overwrite_filep (fname) ) {
 119             char *tmp = ask_outfile_name (NULL, 0);
 120             if ( !tmp || !*tmp ) {
 121                 xfree (tmp);
 122                 rc = G10ERR_CREATE_FILE;
 123                 goto leave;
 124             }
 125             xfree (fname);
 126             fname = tmp;
 127         }
 128     }
 129
 130 #ifndef __riscos__
 131     if( fp || nooutput )
 132         ;
 133     else if (is_secured_filename (fname))
 134       {
 135         errno = EPERM;
 136         log_error(_("error creating `%s': %s\n"), fname, strerror(errno) );
 137         rc = G10ERR_CREATE_FILE;
 138         goto leave;
 139       }
 140     else if( !(fp = fopen(fname,"wb")) ) {
 141         log_error(_("error creating `%s': %s\n"), fname, strerror(errno) );
 142         rc = G10ERR_CREATE_FILE;
 143         goto leave;
 144     }
 145 #else /* __riscos__ */
 146     /* If no output filename was given, i.e. we constructed it,
 147        convert all '.' in fname to '/' but not vice versa as
 148        we don't create directories! */
 149     if( !opt.outfile )
 150         for( c=0; fname[c]; ++c )
 151             if( fname[c] == '.' )
 152                 fname[c] = '/';
 153
 154     if( fp || nooutput )
 155         ;
 156     else {
 157         fp = fopen(fname,"wb");
 158         if( !fp ) {
 159             log_error(_("error creating `%s': %s\n"), fname, strerror(errno) );
 160             rc = G10ERR_CREATE_FILE;
 161             if (errno == 106)
 162                 log_info("Do output file and input file have the same name?\n");
 163             goto leave;
 164         }
 165
 166         /* If there's a ,xxx extension in the embedded filename,
 167            use that, else check whether the user input (in fname)
 168            has a ,xxx appended, then use that in preference */
 169         if( (c = riscos_get_filetype_from_string( pt->name,
 170                                                   pt->namelen )) != -1 )
 171             filetype = c;
 172         if( (c = riscos_get_filetype_from_string( fname,
 173                                                   strlen(fname) )) != -1 )
 174             filetype = c;
 175         riscos_set_filetype_by_number(fname, filetype);
 176     }
 177 #endif /* __riscos__ */
 178
 179     if( !pt->is_partial ) {
 180         /* we have an actual length (which might be zero). */
 181         assert( !clearsig );
 182         if( convert ) { /* text mode */
 183             for( ; pt->len; pt->len-- ) {
 184                 if( (c = iobuf_get(pt->buf)) == -1 ) {
 185                     log_error("Problem reading source (%u bytes remaining)\n",
 186                               (unsigned)pt->len);
 187                     rc = G10ERR_READ_FILE;
 188                     goto leave;
 189                 }
 190                 if( mfx->md )
 191                     md_putc(mfx->md, c );
 192 #ifndef HAVE_DOSISH_SYSTEM
 193                 if( c == '\r' )  /* convert to native line ending */
 194                     continue;    /* fixme: this hack might be too simple */
 195 #endif
 196                 if( fp )
 197                   {
 198                     if(opt.max_output && (++count)>opt.max_output)
 199                       {
 200                         log_error("Error writing to `%s': %s\n",
 201                                   fname,"exceeded --max-output limit\n");
 202                         rc = G10ERR_WRITE_FILE;
 203                         goto leave;
 204                       }
 205                     else if( putc( c, fp ) == EOF )
 206                       {
 207                         log_error("Error writing to `%s': %s\n",
 208                                   fname, strerror(errno) );
 209                         rc = G10ERR_WRITE_FILE;
 210                         goto leave;
 211                       }
 212                   }
 213             }
 214         }
 215         else { /* binary mode */
 216             byte *buffer = xmalloc( 32768 );
 217             while( pt->len ) {
 218                 int len = pt->len > 32768 ? 32768 : pt->len;
 219                 len = iobuf_read( pt->buf, buffer, len );
 220                 if( len == -1 ) {
 221                     log_error("Problem reading source (%u bytes remaining)\n",
 222                               (unsigned)pt->len);
 223                     rc = G10ERR_READ_FILE;
 224                     xfree( buffer );
 225                     goto leave;
 226                 }
 227                 if( mfx->md )
 228                     md_write( mfx->md, buffer, len );
 229                 if( fp )
 230                   {
 231                     if(opt.max_output && (count+=len)>opt.max_output)
 232                       {
 233                         log_error("Error writing to `%s': %s\n",
 234                                   fname,"exceeded --max-output limit\n");
 235                         rc = G10ERR_WRITE_FILE;
 236                         xfree( buffer );
 237                         goto leave;
 238                       }
 239                     else if( fwrite( buffer, 1, len, fp ) != len )
 240                       {
 241                         log_error("Error writing to `%s': %s\n",
 242                                   fname, strerror(errno) );
 243                         rc = G10ERR_WRITE_FILE;
 244                         xfree( buffer );
 245                         goto leave;
 246                       }
 247                   }
 248                 pt->len -= len;
 249             }
 250             xfree( buffer );
 251         }
 252     }
 253     else if( !clearsig ) {
 254         if( convert ) { /* text mode */
 255             while( (c = iobuf_get(pt->buf)) != -1 ) {
 256                 if( mfx->md )
 257                     md_putc(mfx->md, c );
 258 #ifndef HAVE_DOSISH_SYSTEM
 259                 if( convert && c == '\r' )
 260                     continue; /* fixme: this hack might be too simple */
 261 #endif
 262                 if( fp )
 263                   {
 264                     if(opt.max_output && (++count)>opt.max_output)
 265                       {
 266                         log_error("Error writing to `%s': %s\n",
 267                                   fname,"exceeded --max-output limit\n");
 268                         rc = G10ERR_WRITE_FILE;
 269                         goto leave;
 270                       }
 271                     else if( putc( c, fp ) == EOF )
 272                       {
 273                         log_error("Error writing to `%s': %s\n",
 274                                   fname, strerror(errno) );
 275                         rc = G10ERR_WRITE_FILE;
 276                         goto leave;
 277                       }
 278                   }
 279             }
 280         }
 281         else { /* binary mode */
 282             byte *buffer = xmalloc( 32768 );
 283             int eof;
 284             for( eof=0; !eof; ) {
 285                 /* Why do we check for len < 32768:
 286                  * If we won't, we would practically read 2 EOFs but
 287                  * the first one has already popped the block_filter
 288                  * off and therefore we don't catch the boundary.
 289                  * So, always assume EOF if iobuf_read returns less bytes
 290                  * then requested */
 291                 int len = iobuf_read( pt->buf, buffer, 32768 );
 292                 if( len == -1 )
 293                     break;
 294                 if( len < 32768 )
 295                     eof = 1;
 296                 if( mfx->md )
 297                     md_write( mfx->md, buffer, len );
 298                 if( fp )
 299                   {
 300                     if(opt.max_output && (count+=len)>opt.max_output)
 301                       {
 302                         log_error("Error writing to `%s': %s\n",
 303                                   fname,"exceeded --max-output limit\n");
 304                         rc = G10ERR_WRITE_FILE;
 305                         xfree( buffer );
 306                         goto leave;
 307                       }
 308                     else if( fwrite( buffer, 1, len, fp ) != len ) {
 309                       log_error("Error writing to `%s': %s\n",
 310                                 fname, strerror(errno) );
 311                       rc = G10ERR_WRITE_FILE;
 312                       xfree( buffer );
 313                       goto leave;
 314                     }
 315                   }
 316             }
 317             xfree( buffer );
 318         }
 319         pt->buf = NULL;
 320     }
 321     else {  /* clear text signature - don't hash the last cr,lf  */
 322         int state = 0;
 323
 324         while( (c = iobuf_get(pt->buf)) != -1 ) {
 325             if( fp )
 326               {
 327                 if(opt.max_output && (++count)>opt.max_output)
 328                   {
 329                     log_error("Error writing to `%s': %s\n",
 330                               fname,"exceeded --max-output limit\n");
 331                     rc = G10ERR_WRITE_FILE;
 332                     goto leave;
 333                   }
 334                 else if( putc( c, fp ) == EOF )
 335                   {
 336                     log_error("Error writing to `%s': %s\n",
 337                               fname, strerror(errno) );
 338                     rc = G10ERR_WRITE_FILE;
 339                     goto leave;
 340                   }
 341               }
 342             if( !mfx->md )
 343                 continue;
 344             if( state == 2 ) {
 345                 md_putc(mfx->md, '\r' );
 346                 md_putc(mfx->md, '\n' );
 347                 state = 0;
 348             }
 349             if( !state ) {
 350                 if( c == '\r'  )
 351                     state = 1;
 352                 else if( c == '\n'  )
 353                     state = 2;
 354                 else
 355                     md_putc(mfx->md, c );
 356             }
 357             else if( state == 1 ) {
 358                 if( c == '\n'  )
 359                     state = 2;
 360                 else {
 361                     md_putc(mfx->md, '\r' );
 362                     if( c == '\r'  )
 363                         state = 1;
 364                     else {
 365                         state = 0;
 366                         md_putc(mfx->md, c );
 367                     }
 368                 }
 369             }
 370         }
 371         pt->buf = NULL;
 372     }
 373
 374     if( fp && fp != stdout && fclose(fp) ) {
 375         log_error("Error closing `%s': %s\n", fname, strerror(errno) );
 376         fp = NULL;
 377         rc = G10ERR_WRITE_FILE;
 378         goto leave;
 379     }
 380     fp = NULL;
 381
 382   leave:
 383     if( fp && fp != stdout )
 384         fclose(fp);
 385     xfree(fname);
 386     return rc;
 387 }
 388
 389 static void
 390 do_hash( MD_HANDLE md, MD_HANDLE md2, IOBUF fp, int textmode )
 391 {
 392     text_filter_context_t tfx;
 393     int c;
 394
 395     if( textmode ) {
 396         memset( &tfx, 0, sizeof tfx);
 397         iobuf_push_filter( fp, text_filter, &tfx );
 398     }
 399     if( md2 ) { /* work around a strange behaviour in pgp2 */
 400         /* It seems that at least PGP5 converts a single CR to a CR,LF too */
 401         int lc = -1;
 402         while( (c = iobuf_get(fp)) != -1 ) {
 403             if( c == '\n' && lc == '\r' )
 404                 md_putc(md2, c);
 405             else if( c == '\n' ) {
 406                 md_putc(md2, '\r');
 407                 md_putc(md2, c);
 408             }
 409             else if( c != '\n' && lc == '\r' ) {
 410                 md_putc(md2, '\n');
 411                 md_putc(md2, c);
 412             }
 413             else
 414                 md_putc(md2, c);
 415
 416             if( md )
 417                 md_putc(md, c );
 418             lc = c;
 419         }
 420     }
 421     else {
 422         while( (c = iobuf_get(fp)) != -1 ) {
 423             if( md )
 424                 md_putc(md, c );
 425         }
 426     }
 427 }
 428
 429
 430 /****************
 431  * Ask for the detached datafile and calculate the digest from it.
 432  * INFILE is the name of the input file.
 433  */
 434 int
 435 ask_for_detached_datafile( MD_HANDLE md, MD_HANDLE md2,
 436                            const char *inname, int textmode )
 437 {
 438     progress_filter_context_t pfx;
 439     char *answer = NULL;
 440     IOBUF fp;
 441     int rc = 0;
 442
 443     fp = open_sigfile( inname, &pfx ); /* open default file */
 444
 445     if( !fp && !opt.batch ) {
 446         int any=0;
 447         tty_printf(_("Detached signature.\n"));
 448         do {
 449             xfree(answer);
 450             tty_enable_completion(NULL);
 451             answer = cpr_get("detached_signature.filename",
 452                            _("Please enter name of data file: "));
 453             tty_disable_completion();
 454             cpr_kill_prompt();
 455             if( any && !*answer ) {
 456                 rc = G10ERR_READ_FILE;
 457                 goto leave;
 458             }
 459             fp = iobuf_open(answer);
 460             if (fp && is_secured_file (iobuf_get_fd (fp)))
 461               {
 462                 iobuf_close (fp);
 463                 fp = NULL;
 464                 errno = EPERM;
 465               }
 466             if( !fp && errno == ENOENT ) {
 467                 tty_printf("No such file, try again or hit enter to quit.\n");
 468                 any++;
 469             }
 470             else if( !fp )
 471               {
 472                 log_error(_("can't open `%s': %s\n"), answer, strerror(errno));
 473                 rc = G10ERR_READ_FILE;
 474                 goto leave;
 475               }
 476         } while( !fp );
 477     }
 478
 479     if( !fp ) {
 480         if( opt.verbose )
 481             log_info(_("reading stdin ...\n"));
 482         fp = iobuf_open( NULL );
 483         assert(fp);
 484     }
 485     do_hash( md, md2, fp, textmode );
 486     iobuf_close(fp);
 487
 488   leave:
 489     xfree(answer);
 490     return rc;
 491 }
 492
 493
 494
 495 /****************
 496  * Hash the given files and append the hash to hash context md.
 497  * If FILES is NULL, hash stdin.
 498  */
 499 int
 500 hash_datafiles( MD_HANDLE md, MD_HANDLE md2, STRLIST files,
 501                 const char *sigfilename, int textmode )
 502 {
 503     progress_filter_context_t pfx;
 504     IOBUF fp;
 505     STRLIST sl;
 506
 507     if( !files ) {
 508         /* check whether we can open the signed material */
 509         fp = open_sigfile( sigfilename, &pfx );
 510         if( fp ) {
 511             do_hash( md, md2, fp, textmode );
 512             iobuf_close(fp);
 513             return 0;
 514         }
 515         log_error (_("no signed data\n"));
 516         return G10ERR_OPEN_FILE;
 517     }
 518
 519
 520     for (sl=files; sl; sl = sl->next ) {
 521         fp = iobuf_open( sl->d );
 522         if (fp && is_secured_file (iobuf_get_fd (fp)))
 523           {
 524             iobuf_close (fp);
 525             fp = NULL;
 526             errno = EPERM;
 527           }
 528         if( !fp ) {
 529             log_error(_("can't open signed data `%s'\n"),
 530                                                 print_fname_stdin(sl->d));
 531             return G10ERR_OPEN_FILE;
 532         }
 533         handle_progress (&pfx, fp, sl->d);
 534         do_hash( md, md2, fp, textmode );
 535         iobuf_close(fp);
 536     }
 537
 538     return 0;
 539 }