* import.c (parse_import_options), export.c (parse_export_options): Fix
[gnupg.git] / g10 / encode.c
1 /* encode.c - encode data
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "iobuf.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "main.h"
36 #include "filter.h"
37 #include "trustdb.h"
38 #include "i18n.h"
39 #include "status.h"
40
41 static int encode_simple( const char *filename, int mode, int compat );
42 static int write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, IOBUF out );
43
44
45
46 /****************
47  * Encode FILENAME with only the symmetric cipher.  Take input from
48  * stdin if FILENAME is NULL.
49  */
50 int
51 encode_symmetric( const char *filename )
52 {
53     int compat = 1;
54
55 #if 0    
56     /* We don't want to use it because older gnupg version can't
57        handle it and we can presume that a lot of scripts are running
58        with the expert mode set.  Some time in the future we might
59        want to allow for it. */
60     if ( opt.expert )
61         compat = 0; /* PGP knows how to handle this mode. */
62 #endif
63     return encode_simple( filename, 1, compat );
64 }
65
66 /****************
67  * Encode FILENAME as a literal data packet only. Take input from
68  * stdin if FILENAME is NULL.
69  */
70 int
71 encode_store( const char *filename )
72 {
73     return encode_simple( filename, 0, 1 );
74 }
75
76 static void
77 encode_sesskey( DEK *dek, DEK **ret_dek, byte *enckey )
78 {
79     CIPHER_HANDLE hd;
80     DEK *c;
81     byte buf[33];
82
83     assert ( dek->keylen < 32 );
84     
85     c = m_alloc_clear( sizeof *c );
86     c->keylen = dek->keylen;
87     c->algo = dek->algo;
88     make_session_key( c );
89     /*log_hexdump( "thekey", c->key, c->keylen );*/
90
91     buf[0] = c->algo;
92     memcpy( buf + 1, c->key, c->keylen );
93     
94     hd = cipher_open( dek->algo, CIPHER_MODE_CFB, 1 );
95     cipher_setkey( hd, dek->key, dek->keylen );
96     cipher_setiv( hd, NULL, 0 );
97     cipher_encrypt( hd, buf, buf, c->keylen + 1 );
98     cipher_close( hd );
99
100     memcpy( enckey, buf, c->keylen + 1 );
101     memset( buf, 0, sizeof buf ); /* burn key */
102     *ret_dek = c;
103 }
104
105 static int
106 encode_simple( const char *filename, int mode, int compat )
107 {
108     IOBUF inp, out;
109     PACKET pkt;
110     DEK *dek = NULL;
111     PKT_plaintext *pt = NULL;
112     STRING2KEY *s2k = NULL;
113     byte enckey[33];
114     int rc = 0;
115     int seskeylen = 0;
116     u32 filesize;
117     cipher_filter_context_t cfx;
118     armor_filter_context_t afx;
119     compress_filter_context_t zfx;
120     text_filter_context_t tfx;
121     int do_compress = opt.compress && !opt.rfc1991;
122
123     memset( &cfx, 0, sizeof cfx);
124     memset( &afx, 0, sizeof afx);
125     memset( &zfx, 0, sizeof zfx);
126     memset( &tfx, 0, sizeof tfx);
127     init_packet(&pkt);
128     
129     if (opt.compress == -1 && is_file_compressed(filename, &rc))
130       {
131         if (opt.verbose)
132           log_info(_("`%s' already compressed\n"), filename);
133         do_compress = 0;        
134       }
135     if (rc)
136         return rc;
137
138     /* prepare iobufs */
139     if( !(inp = iobuf_open(filename)) ) {
140         log_error(_("%s: can't open: %s\n"), filename? filename: "[stdin]",
141                                         strerror(errno) );
142         return G10ERR_OPEN_FILE;
143     }
144
145     if( opt.textmode )
146         iobuf_push_filter( inp, text_filter, &tfx );
147
148     /* Due the the fact that we use don't use an IV to encrypt the
149        session key we can't use the new mode with RFC1991 because
150        it has no S2K salt. RFC1991 always uses simple S2K. */
151     if ( opt.rfc1991 && !compat )
152         compat = 1;
153     
154     cfx.dek = NULL;
155     if( mode ) {
156         s2k = m_alloc_clear( sizeof *s2k );
157         s2k->mode = opt.rfc1991? 0:opt.s2k_mode;
158         s2k->hash_algo = opt.def_digest_algo ? opt.def_digest_algo
159                                              : opt.s2k_digest_algo;
160         cfx.dek = passphrase_to_dek( NULL, 0,
161                   opt.def_cipher_algo ? opt.def_cipher_algo
162                                       : opt.s2k_cipher_algo , s2k, 2, NULL );
163         if( !cfx.dek || !cfx.dek->keylen ) {
164             rc = G10ERR_PASSPHRASE;
165             m_free(cfx.dek);
166             m_free(s2k);
167             iobuf_close(inp);
168             log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
169             return rc;
170         }
171         if ( !compat ) {            
172             seskeylen = cipher_get_keylen( opt.def_cipher_algo ?
173                                            opt.def_cipher_algo:
174                                            opt.s2k_cipher_algo ) / 8;
175             encode_sesskey( cfx.dek, &dek, enckey );
176             m_free( cfx.dek ); cfx.dek = dek;
177         }
178     }
179
180     if( (rc = open_outfile( filename, opt.armor? 1:0, &out )) ) {
181         iobuf_cancel(inp);
182         m_free(cfx.dek);
183         m_free(s2k);
184         return rc;
185     }
186
187     if( opt.armor )
188         iobuf_push_filter( out, armor_filter, &afx );
189   #ifdef ENABLE_COMMENT_PACKETS
190     else {
191         write_comment( out, "#created by GNUPG v" VERSION " ("
192                                             PRINTABLE_OS_NAME ")");
193         if( opt.comment_string )
194             write_comment( out, opt.comment_string );
195     }
196   #endif
197     if( s2k && !opt.rfc1991 ) {
198         PKT_symkey_enc *enc = m_alloc_clear( sizeof *enc + seskeylen + 1 );
199         enc->version = 4;
200         enc->cipher_algo = cfx.dek->algo;
201         enc->s2k = *s2k;
202         if ( !compat && seskeylen ) {
203             enc->seskeylen = seskeylen + 1; /* algo id */
204             memcpy( enc->seskey, enckey, seskeylen + 1 );
205         }
206         pkt.pkttype = PKT_SYMKEY_ENC;
207         pkt.pkt.symkey_enc = enc;
208         if( (rc = build_packet( out, &pkt )) )
209             log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
210         m_free(enc);
211     }
212
213     if (!opt.no_literal) {
214         /* setup the inner packet */
215         if( filename || opt.set_filename ) {
216             char *s = make_basename( opt.set_filename ? opt.set_filename
217                                                       : filename );
218             pt = m_alloc( sizeof *pt + strlen(s) - 1 );
219             pt->namelen = strlen(s);
220             memcpy(pt->name, s, pt->namelen );
221             m_free(s);
222         }
223         else { /* no filename */
224             pt = m_alloc( sizeof *pt - 1 );
225             pt->namelen = 0;
226         }
227     }
228
229     /* Note that PGP 5 has problems decrypting symmetrically encrypted
230        data if the file length is in the inner packet. It works when
231        only partial length headers are use.  In the past, we always
232        used partial body length here, but since PGP 2, PGP 6, and PGP
233        7 need the file length, and nobody should be using PGP 5
234        nowadays anyway, this is now set to the file length.  Note also
235        that this only applies to the RFC-1991 style symmetric
236        messages, and not the RFC-2440 style.  PGP 6 and 7 work with
237        either partial length or fixed length with the new style
238        messages. */
239
240     if( filename && !opt.textmode ) {
241         if( !(filesize = iobuf_get_filelength(inp)) )
242             log_info(_("%s: WARNING: empty file\n"), filename );
243         /* we can't yet encode the length of very large files,
244          * so we switch to partial lengthn encoding in this case */
245         if ( filesize >= IOBUF_FILELENGTH_LIMIT )
246             filesize = 0;
247
248     }
249     else
250         filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
251
252     if (!opt.no_literal) {
253         pt->timestamp = make_timestamp();
254         pt->mode = opt.textmode? 't' : 'b';
255         pt->len = filesize;
256         pt->new_ctb = !pt->len && !opt.rfc1991;
257         pt->buf = inp;
258         pkt.pkttype = PKT_PLAINTEXT;
259         pkt.pkt.plaintext = pt;
260         cfx.datalen = filesize && !do_compress ? calc_packet_length( &pkt ) : 0;
261     }
262     else
263       {
264         cfx.datalen = filesize && !do_compress ? filesize : 0;
265         pkt.pkttype = 0;
266         pkt.pkt.generic = NULL;
267       }
268
269     /* register the cipher filter */
270     if( mode )
271         iobuf_push_filter( out, cipher_filter, &cfx );
272     /* register the compress filter */
273     if( do_compress )
274         iobuf_push_filter( out, compress_filter, &zfx );
275
276     /* do the work */
277     if (!opt.no_literal) {
278         if( (rc = build_packet( out, &pkt )) )
279             log_error("build_packet failed: %s\n", g10_errstr(rc) );
280     }
281     else {
282         /* user requested not to create a literal packet,
283          * so we copy the plain data */
284         byte copy_buffer[4096];
285         int  bytes_copied;
286         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
287             if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
288                 rc = G10ERR_WRITE_FILE;
289                 log_error("copying input to output failed: %s\n", g10_errstr(rc) );
290                 break;
291             }
292         memset(copy_buffer, 0, 4096); /* burn buffer */
293     }
294
295     /* finish the stuff */
296     iobuf_close(inp);
297     if (rc)
298         iobuf_cancel(out);
299     else {
300         iobuf_close(out); /* fixme: check returncode */
301         if (mode)
302             write_status( STATUS_END_ENCRYPTION );
303     }
304     if (pt)
305         pt->buf = NULL;
306     free_packet(&pkt);
307     m_free(cfx.dek);
308     m_free(s2k);
309     return rc;
310 }
311
312 /****************
313  * Encrypt the file with the given userids (or ask if none
314  * is supplied).
315  */
316 int
317 encode_crypt( const char *filename, STRLIST remusr )
318 {
319     IOBUF inp = NULL, out = NULL;
320     PACKET pkt;
321     PKT_plaintext *pt = NULL;
322     int rc = 0, rc2 = 0;
323     u32 filesize;
324     cipher_filter_context_t cfx;
325     armor_filter_context_t afx;
326     compress_filter_context_t zfx;
327     text_filter_context_t tfx;
328     PK_LIST pk_list,work_list;
329     int do_compress = opt.compress && !opt.rfc1991;
330
331
332     memset( &cfx, 0, sizeof cfx);
333     memset( &afx, 0, sizeof afx);
334     memset( &zfx, 0, sizeof zfx);
335     memset( &tfx, 0, sizeof tfx);
336     init_packet(&pkt);
337
338     if( (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC)) )
339         return rc;
340
341     if(opt.pgp2) {
342       for(work_list=pk_list; work_list; work_list=work_list->next)
343         if(!(is_RSA(work_list->pk->pubkey_algo) &&
344              nbits_from_pk(work_list->pk)<=2048))
345           {
346             log_info(_("you can only encrypt to RSA keys of 2048 bits or "
347                        "less in --pgp2 mode\n"));
348             log_info(_("this message may not be usable by PGP 2.x\n"));
349             opt.pgp2=0;
350             break;
351           }
352     }
353
354     if (opt.compress == -1 && is_file_compressed(filename, &rc2))
355       {
356         if (opt.verbose)
357           log_info(_("`%s' already compressed\n"), filename);
358         do_compress = 0;        
359       }
360     if (rc2)
361       {
362         rc = rc2;
363         goto leave;
364       }
365     
366     /* prepare iobufs */
367     if( !(inp = iobuf_open(filename)) ) {
368         log_error(_("can't open %s: %s\n"), filename? filename: "[stdin]",
369                                         strerror(errno) );
370         rc = G10ERR_OPEN_FILE;
371         goto leave;
372     }
373     else if( opt.verbose )
374         log_info(_("reading from `%s'\n"), filename? filename: "[stdin]");
375
376     if( opt.textmode )
377         iobuf_push_filter( inp, text_filter, &tfx );
378
379     if( (rc = open_outfile( filename, opt.armor? 1:0, &out )) )
380         goto leave;
381
382
383     if( opt.armor )
384         iobuf_push_filter( out, armor_filter, &afx );
385   #ifdef ENABLE_COMMENT_PACKETS
386     else {
387         write_comment( out, "#created by GNUPG v" VERSION " ("
388                                             PRINTABLE_OS_NAME ")");
389         if( opt.comment_string )
390             write_comment( out, opt.comment_string );
391     }
392   #endif
393     /* create a session key */
394     cfx.dek = m_alloc_secure_clear (sizeof *cfx.dek);
395     if( !opt.def_cipher_algo ) { /* try to get it from the prefs */
396         cfx.dek->algo = select_algo_from_prefs(pk_list,PREFTYPE_SYM,-1,NULL);
397         /* The only way select_algo_from_prefs can fail here is when
398            mixing v3 and v4 keys, as v4 keys have an implicit
399            preference entry for 3DES, and the pk_list cannot be empty.
400            In this case, use 3DES anyway as it's the safest choice -
401            perhaps the v3 key is being used in an OpenPGP
402            implementation and we know that the implementation behind
403            any v4 key can handle 3DES. */
404         if( cfx.dek->algo == -1 ) {
405             cfx.dek->algo = CIPHER_ALGO_3DES;
406
407             if( opt.pgp2 ) {
408               log_info(_("unable to use the IDEA cipher for all of the keys "
409                          "you are encrypting to.\n"));
410               log_info(_("this message may not be usable by PGP 2.x\n"));
411               opt.pgp2=0;
412             }
413         }
414     }
415     else {
416       if(!opt.expert &&
417          select_algo_from_prefs(pk_list,PREFTYPE_SYM,
418                                 opt.def_cipher_algo,NULL)!=opt.def_cipher_algo)
419         log_info(_("forcing symmetric cipher %s (%d) "
420                    "violates recipient preferences\n"),
421                  cipher_algo_to_string(opt.def_cipher_algo),
422                  opt.def_cipher_algo);
423
424       cfx.dek->algo = opt.def_cipher_algo;
425     }
426     cfx.dek->use_mdc = select_mdc_from_pklist (pk_list);
427
428     make_session_key( cfx.dek );
429     if( DBG_CIPHER )
430         log_hexdump("DEK is: ", cfx.dek->key, cfx.dek->keylen );
431
432     rc = write_pubkey_enc_from_list( pk_list, cfx.dek, out );
433     if( rc  )
434         goto leave;
435
436     if (!opt.no_literal) {
437         /* setup the inner packet */
438         if( filename || opt.set_filename ) {
439             char *s = make_basename( opt.set_filename ? opt.set_filename : filename );
440             pt = m_alloc( sizeof *pt + strlen(s) - 1 );
441             pt->namelen = strlen(s);
442             memcpy(pt->name, s, pt->namelen );
443             m_free(s);
444         }
445         else { /* no filename */
446             pt = m_alloc( sizeof *pt - 1 );
447             pt->namelen = 0;
448         }
449     }
450
451     if( filename && !opt.textmode ) {
452         if( !(filesize = iobuf_get_filelength(inp)) )
453             log_info(_("%s: WARNING: empty file\n"), filename );
454         /* we can't yet encode the length of very large files,
455          * so we switch to partial length encoding in this case */
456         if ( filesize >= IOBUF_FILELENGTH_LIMIT )
457             filesize = 0;
458     }
459     else
460         filesize = opt.set_filesize ? opt.set_filesize : 0; /* stdin */
461
462     if (!opt.no_literal) {
463         pt->timestamp = make_timestamp();
464         pt->mode = opt.textmode ? 't' : 'b';
465         pt->len = filesize;
466         pt->new_ctb = !pt->len && !opt.rfc1991;
467         pt->buf = inp;
468         pkt.pkttype = PKT_PLAINTEXT;
469         pkt.pkt.plaintext = pt;
470         cfx.datalen = filesize && !do_compress? calc_packet_length( &pkt ) : 0;
471     }
472     else
473         cfx.datalen = filesize && !do_compress ? filesize : 0;
474
475     /* register the cipher filter */
476     iobuf_push_filter( out, cipher_filter, &cfx );
477
478     /* register the compress filter */
479     if( do_compress ) {
480         int compr_algo = opt.def_compress_algo;
481
482         if(compr_algo==-1)
483           {
484             if((compr_algo=
485                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,-1,NULL))==-1)
486               compr_algo=DEFAULT_COMPRESS_ALGO;
487           }
488         else if(!opt.expert &&
489                 select_algo_from_prefs(pk_list,PREFTYPE_ZIP,
490                                        compr_algo,NULL)!=compr_algo)
491           log_info(_("forcing compression algorithm %s (%d) "
492                      "violates recipient preferences\n"),
493                    compress_algo_to_string(compr_algo),compr_algo);
494
495         /* algo 0 means no compression */
496         if( compr_algo )
497           {
498             zfx.algo = compr_algo;
499             iobuf_push_filter( out, compress_filter, &zfx );
500           }
501     }
502
503     /* do the work */
504     if (!opt.no_literal) {
505         if( (rc = build_packet( out, &pkt )) )
506             log_error("build_packet failed: %s\n", g10_errstr(rc) );
507     }
508     else {
509         /* user requested not to create a literal packet, so we copy the plain data */
510         byte copy_buffer[4096];
511         int  bytes_copied;
512         while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
513             if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
514                 rc = G10ERR_WRITE_FILE;
515                 log_error("copying input to output failed: %s\n", g10_errstr(rc) );
516                 break;
517             }
518         memset(copy_buffer, 0, 4096); /* burn buffer */
519     }
520
521     /* finish the stuff */
522   leave:
523     iobuf_close(inp);
524     if( rc )
525         iobuf_cancel(out);
526     else {
527         iobuf_close(out); /* fixme: check returncode */
528         write_status( STATUS_END_ENCRYPTION );
529     }
530     if( pt )
531         pt->buf = NULL;
532     free_packet(&pkt);
533     m_free(cfx.dek);
534     release_pk_list( pk_list );
535     return rc;
536 }
537
538
539
540
541 /****************
542  * Filter to do a complete public key encryption.
543  */
544 int
545 encrypt_filter( void *opaque, int control,
546                IOBUF a, byte *buf, size_t *ret_len)
547 {
548     size_t size = *ret_len;
549     encrypt_filter_context_t *efx = opaque;
550     int rc=0;
551
552     if( control == IOBUFCTRL_UNDERFLOW ) { /* decrypt */
553         BUG(); /* not used */
554     }
555     else if( control == IOBUFCTRL_FLUSH ) { /* encrypt */
556         if( !efx->header_okay ) {
557             efx->cfx.dek = m_alloc_secure_clear( sizeof *efx->cfx.dek );
558
559             if( !opt.def_cipher_algo  ) { /* try to get it from the prefs */
560                 efx->cfx.dek->algo =
561                   select_algo_from_prefs(efx->pk_list,PREFTYPE_SYM,-1,NULL);
562                 if( efx->cfx.dek->algo == -1 ) {
563                     /* because 3DES is implicitly in the prefs, this can only
564                      * happen if we do not have any public keys in the list */
565                     efx->cfx.dek->algo = DEFAULT_CIPHER_ALGO;
566                 }
567             }
568             else {
569               if(!opt.expert &&
570                  select_algo_from_prefs(efx->pk_list,PREFTYPE_SYM,
571                                         opt.def_cipher_algo,
572                                         NULL)!=opt.def_cipher_algo)
573                 log_info(_("forcing symmetric cipher %s (%d) "
574                            "violates recipient preferences\n"),
575                          cipher_algo_to_string(opt.def_cipher_algo),
576                          opt.def_cipher_algo);
577
578               efx->cfx.dek->algo = opt.def_cipher_algo;
579             }
580
581             efx->cfx.dek->use_mdc = select_mdc_from_pklist (efx->pk_list);
582
583             make_session_key( efx->cfx.dek );
584             if( DBG_CIPHER )
585                 log_hexdump("DEK is: ",
586                              efx->cfx.dek->key, efx->cfx.dek->keylen );
587
588             rc = write_pubkey_enc_from_list( efx->pk_list, efx->cfx.dek, a );
589             if( rc )
590                 return rc;
591
592             iobuf_push_filter( a, cipher_filter, &efx->cfx );
593
594             efx->header_okay = 1;
595         }
596         rc = iobuf_write( a, buf, size );
597
598     }
599     else if( control == IOBUFCTRL_FREE ) {
600     }
601     else if( control == IOBUFCTRL_DESC ) {
602         *(char**)buf = "encrypt_filter";
603     }
604     return rc;
605 }
606
607
608 /****************
609  * Write pubkey-enc packets from the list of PKs to OUT.
610  */
611 static int
612 write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, IOBUF out )
613 {
614     PACKET pkt;
615     PKT_public_key *pk;
616     PKT_pubkey_enc  *enc;
617     int rc;
618
619     for( ; pk_list; pk_list = pk_list->next ) {
620         MPI frame;
621
622         pk = pk_list->pk;
623
624         print_pubkey_algo_note( pk->pubkey_algo );
625         enc = m_alloc_clear( sizeof *enc );
626         enc->pubkey_algo = pk->pubkey_algo;
627         keyid_from_pk( pk, enc->keyid );
628         enc->throw_keyid = opt.throw_keyid;
629
630         /* Okay, what's going on: We have the session key somewhere in
631          * the structure DEK and want to encode this session key in
632          * an integer value of n bits.  pubkey_nbits gives us the
633          * number of bits we have to use.  We then encode the session
634          * key in some way and we get it back in the big intger value
635          * FRAME.  Then we use FRAME, the public key PK->PKEY and the
636          * algorithm number PK->PUBKEY_ALGO and pass it to pubkey_encrypt
637          * which returns the encrypted value in the array ENC->DATA.
638          * This array has a size which depends on the used algorithm
639          * (e.g. 2 for ElGamal).  We don't need frame anymore because we
640          * have everything now in enc->data which is the passed to
641          * build_packet()
642          */
643         frame = encode_session_key( dek, pubkey_nbits( pk->pubkey_algo,
644                                                           pk->pkey ) );
645         rc = pubkey_encrypt( pk->pubkey_algo, enc->data, frame, pk->pkey );
646         mpi_free( frame );
647         if( rc )
648             log_error("pubkey_encrypt failed: %s\n", g10_errstr(rc) );
649         else {
650             if( opt.verbose ) {
651                 char *ustr = get_user_id_string_native( enc->keyid );
652                 log_info(_("%s/%s encrypted for: %s\n"),
653                     pubkey_algo_to_string(enc->pubkey_algo),
654                     cipher_algo_to_string(dek->algo), ustr );
655                 m_free(ustr);
656             }
657             /* and write it */
658             init_packet(&pkt);
659             pkt.pkttype = PKT_PUBKEY_ENC;
660             pkt.pkt.pubkey_enc = enc;
661             rc = build_packet( out, &pkt );
662             if( rc )
663                log_error("build_packet(pubkey_enc) failed: %s\n", g10_errstr(rc));
664         }
665         free_pubkey_enc(enc);
666         if( rc )
667             return rc;
668     }
669     return 0;
670 }
671
672 void
673 encode_crypt_files(int nfiles, char **files, STRLIST remusr)
674 {
675   int rc = 0;
676
677   if (opt.outfile)
678     {
679       log_error(_("--output doesn't work for this command\n"));
680       return;        
681     }
682     
683   if (!nfiles)
684     {
685       char line[2048];
686       unsigned int lno = 0;
687       while ( fgets(line, DIM(line), stdin) )
688         {
689           lno++;
690           if (!*line || line[strlen(line)-1] != '\n')
691             {
692               log_error("input line %u too long or missing LF\n", lno);
693               return;
694             }
695           line[strlen(line)-1] = '\0';
696           print_file_status(STATUS_FILE_START, line, 2);
697           if ( (rc = encode_crypt(line, remusr)) )
698             log_error("%s: encryption failed: %s\n",
699                       print_fname_stdin(line), g10_errstr(rc) );
700           write_status( STATUS_FILE_DONE );
701         }
702     }
703   else
704     {
705       while (nfiles--)
706         {
707           print_file_status(STATUS_FILE_START, *files, 2);
708           if ( (rc = encode_crypt(*files, remusr)) )
709             log_error("%s: encryption failed: %s\n",
710                       print_fname_stdin(*files), g10_errstr(rc) );
711           write_status( STATUS_FILE_DONE );
712           files++;
713         }
714     }
715 }