Improved prime number test
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle packets
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 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  * G10 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
25 #include "packet.h"
26 #include "iobuf.h"
27 #include "memory.h"
28 #include "options.h"
29 #include "util.h"
30 #include "cipher.h"
31 #include "keydb.h"
32 #include "filter.h"
33 #include "main.h"
34
35
36 typedef struct {
37     PKT_pubkey_cert *last_pubkey;
38     PKT_seckey_cert *last_seckey;
39     PKT_user_id     *last_user_id;
40     md_filter_context_t mfx;
41     DEK *dek;
42     int last_was_pubkey_enc;
43 } *CTX;
44
45
46
47
48 static int opt_list=1;  /* and list the data packets to stdout */
49 #if 1
50 static void
51 do_free_last_user_id( CTX c )
52 {
53     if( c->last_user_id ) {
54         free_user_id( c->last_user_id );
55         c->last_user_id = NULL;
56     }
57 }
58 static void
59 do_free_last_pubkey( CTX c )
60 {
61     if( c->last_pubkey ) {
62         free_pubkey_cert( c->last_pubkey );
63         c->last_pubkey = NULL;
64     }
65 }
66 static void
67 do_free_last_seckey( CTX c )
68 {
69     if( c->last_seckey ) {
70         free_seckey_cert( c->last_seckey );
71         c->last_seckey = NULL;
72     }
73 }
74
75 static void
76 proc_pubkey_cert( CTX c, PACKET *pkt )
77 {
78     u32 keyid[2];
79     char *ustr;
80     int lvl0 = opt.check_sigs? 1:0; /* stdout or /dev/null */
81
82     do_free_last_user_id( c );
83     do_free_last_seckey( c );
84     if( opt.check_sigs ) {
85         keyid_from_pkc( pkt->pkt.pubkey_cert, keyid );
86         ustr = get_user_id_string(keyid);
87         printstr(lvl0, "pub: %s\n", ustr );
88         m_free(ustr);
89     }
90     else
91         fputs( "pub: [Public Key Cerificate]\n", stdout );
92     c->last_pubkey = pkt->pkt.pubkey_cert;
93     pkt->pkt.pubkey_cert = NULL;
94     free_packet(pkt);
95     pkt->pkc_parent = c->last_pubkey; /* set this as parent */
96 }
97
98
99 static void
100 proc_seckey_cert( CTX c, PACKET *pkt )
101 {
102     int rc;
103
104     do_free_last_user_id( c );
105     do_free_last_pubkey( c );
106     if( opt_list )
107         fputs( "sec: (secret key certificate)\n", stdout );
108     rc = check_secret_key( pkt->pkt.seckey_cert );
109     if( opt_list ) {
110         if( !rc )
111             fputs( "     Secret key is good", stdout );
112         else
113             fputs( g10_errstr(rc), stdout);
114         putchar('\n');
115     }
116     else if( rc )
117         log_error("secret key certificate error: %s\n", g10_errstr(rc));
118     c->last_seckey = pkt->pkt.seckey_cert;
119     pkt->pkt.seckey_cert = NULL;
120     free_packet(pkt);
121     pkt->skc_parent = c->last_seckey; /* set this as parent */
122 }
123
124
125 static void
126 proc_user_id( CTX c, PACKET *pkt )
127 {
128     u32 keyid[2];
129
130     do_free_last_user_id( c );
131     if( opt_list ) {
132          printf("uid: '%.*s'\n", pkt->pkt.user_id->len,
133                                  pkt->pkt.user_id->name );
134          if( !pkt->pkc_parent && !pkt->skc_parent )
135              puts("      (orphaned)");
136     }
137     if( pkt->pkc_parent ) {
138         if( pkt->pkc_parent->pubkey_algo == PUBKEY_ALGO_ELGAMAL
139             || pkt->pkc_parent->pubkey_algo == PUBKEY_ALGO_RSA ) {
140             keyid_from_pkc( pkt->pkc_parent, keyid );
141             cache_user_id( pkt->pkt.user_id, keyid );
142         }
143     }
144
145     c->last_user_id = pkt->pkt.user_id;  /* save */
146     pkt->pkt.user_id = NULL;
147     free_packet(pkt);
148     pkt->user_parent = c->last_user_id;  /* and set this as user */
149 }
150
151
152 static void
153 proc_signature( CTX c, PACKET *pkt )
154 {
155     PKT_signature *sig;
156     MD_HANDLE md_handle; /* union to pass handles down */
157     char *ustr;
158     int result = -1;
159     int lvl0 = opt.check_sigs? 1:0; /* stdout or /dev/null */
160     int lvl1 = opt.check_sigs? 1:3; /* stdout or error */
161
162     sig = pkt->pkt.signature;
163     ustr = get_user_id_string(sig->keyid);
164     if( sig->sig_class == 0x00 ) {
165         if( c->mfx.rmd160 )
166             result = 0;
167         else
168             printstr(lvl1,"sig?: %s: no plaintext for signature\n", ustr);
169     }
170     else if( sig->sig_class != 0x10 )
171         printstr(lvl1,"sig?: %s: unknown signature class %02x\n",
172                                 ustr, sig->sig_class);
173     else if( !pkt->pkc_parent || !pkt->user_parent )
174         printstr(lvl1,"sig?: %s: orphaned encoded packet\n", ustr);
175     else
176         result = 0;
177
178     if( result )
179         ;
180     else if( !opt.check_sigs && sig->sig_class != 0x00 ) {
181         result = -1;
182         printstr(lvl0, "sig: from %s\n", ustr );
183     }
184     else if(sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
185         md_handle.algo = sig->d.elg.digest_algo;
186         if( sig->d.elg.digest_algo == DIGEST_ALGO_RMD160 ) {
187             if( sig->sig_class == 0x00 )
188                 md_handle.u.rmd = rmd160_copy( c->mfx.rmd160 );
189             else {
190                 md_handle.u.rmd = rmd160_copy(pkt->pkc_parent->mfx.rmd160);
191                 rmd160_write(md_handle.u.rmd, pkt->user_parent->name,
192                                               pkt->user_parent->len);
193             }
194             result = signature_check( sig, md_handle );
195             rmd160_close(md_handle.u.rmd);
196         }
197         else if( sig->d.elg.digest_algo == DIGEST_ALGO_MD5
198                  && sig->sig_class != 0x00 ) {
199             md_handle.u.md5 = md5_copy(pkt->pkc_parent->mfx.md5);
200             md5_write(md_handle.u.md5, pkt->user_parent->name,
201                                           pkt->user_parent->len);
202             result = signature_check( sig, md_handle );
203             md5_close(md_handle.u.md5);
204         }
205         else
206             result = G10ERR_DIGEST_ALGO;
207     }
208     else if(sig->pubkey_algo == PUBKEY_ALGO_RSA ) {
209         md_handle.algo = sig->d.rsa.digest_algo;
210         if( sig->d.rsa.digest_algo == DIGEST_ALGO_RMD160 ) {
211             if( sig->sig_class == 0x00 )
212                 md_handle.u.rmd = rmd160_copy( c->mfx.rmd160 );
213             else {
214                 md_handle.u.rmd = rmd160_copy(pkt->pkc_parent->mfx.rmd160);
215                 rmd160_write(md_handle.u.rmd, pkt->user_parent->name,
216                                                  pkt->user_parent->len);
217             }
218             result = signature_check( sig, md_handle );
219             rmd160_close(md_handle.u.rmd);
220         }
221         else if( sig->d.rsa.digest_algo == DIGEST_ALGO_MD5
222                  && sig->sig_class != 0x00 ) {
223             md_handle.u.md5 = md5_copy(pkt->pkc_parent->mfx.md5);
224             md5_write(md_handle.u.md5, pkt->user_parent->name,
225                                        pkt->user_parent->len);
226             result = signature_check( sig, md_handle );
227             md5_close(md_handle.u.md5);
228         }
229         else
230             result = G10ERR_DIGEST_ALGO;
231     }
232     else
233         result = G10ERR_PUBKEY_ALGO;
234
235     if( result == -1 )
236         ;
237     else if( !result && sig->sig_class == 0x00 )
238         printstr(1,    "sig: good signature from %s\n", ustr );
239     else if( !result )
240         printstr(lvl0, "sig: good signature from %s\n", ustr );
241     else
242         printstr(lvl1, "sig? %s: %s\n", ustr, g10_errstr(result));
243     free_packet(pkt);
244     m_free(ustr);
245 }
246
247
248 static void
249 proc_pubkey_enc( CTX c, PACKET *pkt )
250 {
251     PKT_pubkey_enc *enc;
252     int result = 0;
253
254     c->last_was_pubkey_enc = 1;
255     enc = pkt->pkt.pubkey_enc;
256     printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );
257     if( enc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
258         || enc->pubkey_algo == PUBKEY_ALGO_RSA  ) {
259         m_free(c->dek ); /* paranoid: delete a pending DEK */
260         c->dek = m_alloc_secure( sizeof *c->dek );
261         if( (result = get_session_key( enc, c->dek )) ) {
262             /* error: delete the DEK */
263             m_free(c->dek); c->dek = NULL;
264         }
265     }
266     else
267         result = G10ERR_PUBKEY_ALGO;
268
269     if( result == -1 )
270         ;
271     else if( !result )
272         fputs(  "     DEK is good", stdout );
273     else
274         printf( "     %s", g10_errstr(result));
275     putchar('\n');
276     free_packet(pkt);
277 }
278
279
280
281 static void
282 proc_encr_data( CTX c, PACKET *pkt )
283 {
284     int result = 0;
285
286     printf("dat: %sencrypted data\n", c->dek?"":"conventional ");
287     if( !c->dek && !c->last_was_pubkey_enc ) {
288         /* assume this is conventional encrypted data */
289         c->dek = m_alloc_secure( sizeof *c->dek );
290         c->dek->algo = DEFAULT_CIPHER_ALGO;
291         result = make_dek_from_passphrase( c->dek, 0 );
292     }
293     else if( !c->dek )
294         result = G10ERR_NO_SECKEY;
295     if( !result )
296         result = decrypt_data( pkt->pkt.encr_data, c->dek );
297     m_free(c->dek); c->dek = NULL;
298     if( result == -1 )
299         ;
300     else if( !result )
301         fputs(  "     encryption okay",stdout);
302     else
303         printf( "     %s", g10_errstr(result));
304     putchar('\n');
305     free_packet(pkt);
306     c->last_was_pubkey_enc = 0;
307 }
308
309
310 static void
311 proc_plaintext( CTX c, PACKET *pkt )
312 {
313     PKT_plaintext *pt = pkt->pkt.plaintext;
314     int result;
315
316     printf("txt: plain text data name='%.*s'\n", pt->namelen, pt->name);
317     free_md_filter_context( &c->mfx );
318     c->mfx.rmd160 = rmd160_open(0);
319     result = handle_plaintext( pt, &c->mfx );
320     if( !result )
321         fputs(  "     okay", stdout);
322     else
323         printf( "     %s", g10_errstr(result));
324     putchar('\n');
325     free_packet(pkt);
326     c->last_was_pubkey_enc = 0;
327 }
328
329
330 static void
331 proc_compr_data( CTX c, PACKET *pkt )
332 {
333     PKT_compressed *zd = pkt->pkt.compressed;
334     int result;
335
336     printf("zip: compressed data packet\n");
337     result = handle_compressed( zd );
338     if( !result )
339         fputs(  "     okay", stdout);
340     else
341         printf( "     %s", g10_errstr(result));
342     putchar('\n');
343     free_packet(pkt);
344     c->last_was_pubkey_enc = 0;
345 }
346
347
348
349 int
350 proc_packets( IOBUF a )
351 {
352     CTX c = m_alloc_clear( sizeof *c );
353     PACKET *pkt = m_alloc( sizeof *pkt );
354     int rc, result;
355     char *ustr;
356     int lvl0, lvl1;
357     u32 keyid[2];
358
359     init_packet(pkt);
360     while( (rc=parse_packet(a, pkt)) != -1 ) {
361         /* cleanup if we have an illegal data structure */
362         if( c->dek && pkt->pkttype != PKT_ENCR_DATA ) {
363             log_error("oops: valid pubkey enc packet not followed by data\n");
364             m_free(c->dek); c->dek = NULL; /* burn it */
365         }
366
367         if( rc ) {
368             free_packet(pkt);
369             continue;
370         }
371         switch( pkt->pkttype ) {
372           case PKT_PUBKEY_CERT: proc_pubkey_cert( c, pkt ); break;
373           case PKT_SECKEY_CERT: proc_seckey_cert( c, pkt ); break;
374           case PKT_USER_ID:     proc_user_id( c, pkt ); break;
375           case PKT_SIGNATURE:   proc_signature( c, pkt ); break;
376           case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
377           case PKT_ENCR_DATA:   proc_encr_data( c, pkt ); break;
378           case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
379           case PKT_COMPR_DATA:  proc_compr_data( c, pkt ); break;
380           default: free_packet(pkt);
381         }
382     }
383
384     do_free_last_user_id( c );
385     do_free_last_seckey( c );
386     do_free_last_pubkey( c );
387     m_free(c->dek);
388     free_packet( pkt );
389     m_free( pkt );
390     free_md_filter_context( &c->mfx );
391     m_free( c );
392     return 0;
393 }
394
395 #else /* old */
396 int
397 proc_packets( IOBUF a )
398 {
399     PACKET *pkt;
400     PKT_pubkey_cert *last_pubkey = NULL;
401     PKT_seckey_cert *last_seckey = NULL;
402     PKT_user_id     *last_user_id = NULL;
403     DEK *dek = NULL;
404     PKT_signature *sig; /* CHECK: "might be used uninitialied" */
405     int rc, result;
406     MD_HANDLE md_handle; /* union to pass handles */
407     char *ustr;
408     int lvl0, lvl1;
409     int last_was_pubkey_enc = 0;
410     u32 keyid[2];
411     md_filter_context_t mfx;
412
413     memset( &mfx, 0, sizeof mfx );
414     lvl0 = opt.check_sigs? 1:0; /* stdout or /dev/null */
415     lvl1 = opt.check_sigs? 1:3; /* stdout or error */
416     pkt = m_alloc( sizeof *pkt );
417     init_packet(pkt);
418     while( (rc=parse_packet(a, pkt)) != -1 ) {
419         if( dek && pkt->pkttype != PKT_ENCR_DATA ) {
420             log_error("oops: valid pubkey enc packet not followed by data\n");
421             m_free(dek); dek = NULL; /* burn it */
422         }
423
424         if( rc )
425             free_packet(pkt);
426         else if( pkt->pkttype == PKT_PUBKEY_CERT ) {
427             if( last_user_id ) {
428                 free_user_id( last_user_id );
429                 last_user_id = NULL;
430             }
431             if( last_pubkey ) {
432                 free_pubkey_cert( last_pubkey );
433                 last_pubkey = NULL;
434             }
435             if( opt.check_sigs ) {
436                 ustr = get_user_id_string(sig->keyid);
437                 printstr(lvl0, "pub: %s\n", ustr );
438                 m_free(ustr);
439             }
440             else
441                 fputs( "pub: [Public Key Cerificate]\n", stdout );
442             last_pubkey = pkt->pkt.pubkey_cert;
443             pkt->pkt.pubkey_cert = NULL;
444             free_packet(pkt);
445             pkt->pkc_parent = last_pubkey; /* set this as parent */
446         }
447         else if( pkt->pkttype == PKT_SECKEY_CERT ) {
448             if( last_user_id ) {
449                 free_user_id( last_user_id );
450                 last_user_id = NULL;
451             }
452             if( last_seckey ) {
453                 free_seckey_cert( last_seckey );
454                 last_seckey = NULL;
455             }
456             if( opt_list )
457                 fputs( "sec: (secret key certificate)\n", stdout );
458             rc = check_secret_key( pkt->pkt.seckey_cert );
459             if( opt_list ) {
460                 if( !rc )
461                     fputs( "     Secret key is good", stdout );
462                 else
463                     fputs( g10_errstr(rc), stdout);
464                 putchar('\n');
465             }
466             else if( rc )
467                 log_error("secret key certificate error: %s\n", g10_errstr(rc));
468             last_seckey = pkt->pkt.seckey_cert;
469             pkt->pkt.seckey_cert = NULL;
470             free_packet(pkt);
471             pkt->skc_parent = last_seckey; /* set this as parent */
472         }
473         else if( pkt->pkttype == PKT_USER_ID ) {
474             if( last_user_id ) {
475                 free_user_id( last_user_id );
476                 last_user_id = NULL;
477             }
478             if( opt_list ) {
479                  printf("uid: '%.*s'\n", pkt->pkt.user_id->len,
480                                          pkt->pkt.user_id->name );
481                  if( !pkt->pkc_parent && !pkt->skc_parent )
482                      puts("      (orphaned)");
483             }
484             if( pkt->pkc_parent ) {
485                 if( pkt->pkc_parent->pubkey_algo == PUBKEY_ALGO_ELGAMAL
486                     || pkt->pkc_parent->pubkey_algo == PUBKEY_ALGO_RSA ) {
487                     keyid_from_pkc( pkt->pkc_parent, keyid );
488                     cache_user_id( pkt->pkt.user_id, keyid );
489                 }
490             }
491
492             last_user_id = pkt->pkt.user_id;  /* save */
493             pkt->pkt.user_id = NULL;
494             free_packet(pkt);   /* fixme: free_packet is not a good name */
495             pkt->user_parent = last_user_id;  /* and set this as user */
496         }
497         else if( pkt->pkttype == PKT_SIGNATURE ) {
498             sig = pkt->pkt.signature;
499             ustr = get_user_id_string(sig->keyid);
500             result = -1;
501             if( sig->sig_class == 0x00 ) {
502                 if( mfx.rmd160 )
503                     result = 0;
504                 else
505                     printstr(lvl1,"sig?: %s: no plaintext for signature\n",
506                                                         ustr);
507             }
508             else if( sig->sig_class != 0x10 )
509                 printstr(lvl1,"sig?: %s: unknown signature class %02x\n",
510                                         ustr, sig->sig_class);
511             else if( !pkt->pkc_parent || !pkt->user_parent )
512                 printstr(lvl1,"sig?: %s: orphaned encoded packet\n", ustr);
513             else
514                 result = 0;
515
516             if( result )
517                 ;
518             else if( !opt.check_sigs && sig->sig_class != 0x00 ) {
519                 result = -1;
520                 printstr(lvl0, "sig: from %s\n", ustr );
521             }
522             else if(sig->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
523                 md_handle.algo = sig->d.elg.digest_algo;
524                 if( sig->d.elg.digest_algo == DIGEST_ALGO_RMD160 ) {
525                     if( sig->sig_class == 0x00 )
526                         md_handle.u.rmd = rmd160_copy( mfx.rmd160 );
527                     else {
528                         md_handle.u.rmd = rmd160_copy(pkt->pkc_parent->mfx.rmd160);
529                         rmd160_write(md_handle.u.rmd, pkt->user_parent->name,
530                                                       pkt->user_parent->len);
531                     }
532                     result = signature_check( sig, md_handle );
533                     rmd160_close(md_handle.u.rmd);
534                 }
535                 else if( sig->d.elg.digest_algo == DIGEST_ALGO_MD5
536                          && sig->sig_class != 0x00 ) {
537                     md_handle.u.md5 = md5_copy(pkt->pkc_parent->mfx.md5);
538                     md5_write(md_handle.u.md5, pkt->user_parent->name,
539                                                pkt->user_parent->len);
540                     result = signature_check( sig, md_handle );
541                     md5_close(md_handle.u.md5);
542                 }
543                 else
544                     result = G10ERR_DIGEST_ALGO;
545             }
546             else if(sig->pubkey_algo == PUBKEY_ALGO_RSA ) {
547                 md_handle.algo = sig->d.rsa.digest_algo;
548                 if( sig->d.rsa.digest_algo == DIGEST_ALGO_RMD160 ) {
549                     if( sig->sig_class == 0x00 )
550                         md_handle.u.rmd = rmd160_copy( mfx.rmd160 );
551                     else {
552                         md_handle.u.rmd = rmd160_copy(pkt->pkc_parent->mfx.rmd160);
553                         rmd160_write(md_handle.u.rmd, pkt->user_parent->name,
554                                                       pkt->user_parent->len);
555                     }
556                     result = signature_check( sig, md_handle );
557                     rmd160_close(md_handle.u.rmd);
558                 }
559                 else if( sig->d.rsa.digest_algo == DIGEST_ALGO_MD5
560                          && sig->sig_class != 0x00 ) {
561                     md_handle.u.md5 = md5_copy(pkt->pkc_parent->mfx.md5);
562                     md5_write(md_handle.u.md5, pkt->user_parent->name,
563                                                pkt->user_parent->len);
564                     result = signature_check( sig, md_handle );
565                     md5_close(md_handle.u.md5);
566                 }
567                 else
568                     result = G10ERR_DIGEST_ALGO;
569             }
570             else
571                 result = G10ERR_PUBKEY_ALGO;
572
573             if( result == -1 )
574                 ;
575             else if( !result && sig->sig_class == 0x00 )
576                 printstr(1,    "sig: good signature from %s\n", ustr );
577             else if( !result )
578                 printstr(lvl0, "sig: good signature from %s\n", ustr );
579             else
580                 printstr(lvl1, "sig? %s: %s\n", ustr, g10_errstr(result));
581             free_packet(pkt);
582             m_free(ustr);
583         }
584         else if( pkt->pkttype == PKT_PUBKEY_ENC ) {
585             PKT_pubkey_enc *enc;
586
587             last_was_pubkey_enc = 1;
588             result = 0;
589             enc = pkt->pkt.pubkey_enc;
590             printf("enc: encrypted by a pubkey with keyid %08lX\n",
591                                                         enc->keyid[1] );
592             if( enc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
593                 || enc->pubkey_algo == PUBKEY_ALGO_RSA  ) {
594                 m_free(dek ); /* paranoid: delete a pending DEK */
595                 dek = m_alloc_secure( sizeof *dek );
596                 if( (result = get_session_key( enc, dek )) ) {
597                     /* error: delete the DEK */
598                     m_free(dek); dek = NULL;
599                 }
600             }
601             else
602                 result = G10ERR_PUBKEY_ALGO;
603
604             if( result == -1 )
605                 ;
606             else if( !result )
607                 fputs(  "     DEK is good", stdout );
608             else
609                 printf( "     %s", g10_errstr(result));
610             putchar('\n');
611             free_packet(pkt);
612         }
613         else if( pkt->pkttype == PKT_ENCR_DATA ) {
614             result = 0;
615             printf("dat: %sencrypted data\n", dek?"":"conventional ");
616             if( !dek && !last_was_pubkey_enc ) {
617                 /* assume this is conventional encrypted data */
618                 dek = m_alloc_secure( sizeof *dek );
619                 dek->algo = DEFAULT_CIPHER_ALGO;
620                 result = make_dek_from_passphrase( dek, 0 );
621             }
622             else if( !dek )
623                 result = G10ERR_NO_SECKEY;
624             if( !result )
625                 result = decrypt_data( pkt->pkt.encr_data, dek );
626             m_free(dek); dek = NULL;
627             if( result == -1 )
628                 ;
629             else if( !result )
630                 fputs(  "     encryption okay",stdout);
631             else
632                 printf( "     %s", g10_errstr(result));
633             putchar('\n');
634             free_packet(pkt);
635             last_was_pubkey_enc = 0;
636         }
637         else if( pkt->pkttype == PKT_PLAINTEXT ) {
638             PKT_plaintext *pt = pkt->pkt.plaintext;
639             printf("txt: plain text data name='%.*s'\n", pt->namelen, pt->name);
640             free_md_filter_context( &mfx );
641             mfx.rmd160 = rmd160_open(0);
642             result = handle_plaintext( pt, &mfx );
643             if( !result )
644                 fputs(  "     okay",stdout);
645             else
646                 printf( "     %s", g10_errstr(result));
647             putchar('\n');
648             free_packet(pkt);
649             last_was_pubkey_enc = 0;
650         }
651         else if( pkt->pkttype == PKT_COMPR_DATA ) {
652             PKT_compressed *zd = pkt->pkt.compressed;
653             printf("zip: compressed data packet\n");
654             result = handle_compressed( zd );
655             if( !result )
656                 fputs(  "     okay",stdout);
657             else
658                 printf( "     %s", g10_errstr(result));
659             putchar('\n');
660             free_packet(pkt);
661             last_was_pubkey_enc = 0;
662         }
663         else
664             free_packet(pkt);
665     }
666
667     if( last_user_id )
668         free_user_id( last_user_id );
669     if( last_seckey )
670         free_seckey_cert( last_seckey );
671     if( last_pubkey )
672         free_pubkey_cert( last_pubkey );
673     m_free(dek);
674     free_packet( pkt );
675     m_free( pkt );
676     free_md_filter_context( &mfx );
677     return 0;
678 }
679 #endif
680