auto retrieve keys from PKA. Thsi allows to specify an email address
[gnupg.git] / g10 / mainproc.c
1 /* mainproc.c - handle 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 <assert.h>
28 #include <time.h>
29
30 #include "packet.h"
31 #include "iobuf.h"
32 #include "memory.h"
33 #include "options.h"
34 #include "util.h"
35 #include "cipher.h"
36 #include "keydb.h"
37 #include "filter.h"
38 #include "main.h"
39 #include "status.h"
40 #include "i18n.h"
41 #include "trustdb.h"
42 #include "keyserver-internal.h"
43 #include "photoid.h"
44
45
46 struct kidlist_item {
47     struct kidlist_item *next;
48     u32 kid[2];
49     int pubkey_algo;
50     int reason;
51 };
52
53
54 /****************
55  * Structure to hold the context
56  */
57 typedef struct mainproc_context *CTX;
58 struct mainproc_context {
59     struct mainproc_context *anchor;  /* may be useful in the future */
60     PKT_public_key *last_pubkey;
61     PKT_secret_key *last_seckey;
62     PKT_user_id     *last_user_id;
63     md_filter_context_t mfx;
64     int sigs_only;   /* process only signatures and reject all other stuff */
65     int encrypt_only; /* process only encrytion messages */
66     STRLIST signed_data;
67     const char *sigfilename;
68     DEK *dek;
69     int last_was_session_key;
70     KBNODE list;   /* the current list of packets */
71     int have_data;
72     IOBUF iobuf;    /* used to get the filename etc. */
73     int trustletter; /* temp usage in list_node */
74     ulong symkeys;
75     struct kidlist_item *pkenc_list;    /* list of encryption packets */
76     struct {
77         int op;
78         int stop_now;
79     } pipemode;
80 };
81
82
83 static int do_proc_packets( CTX c, IOBUF a );
84
85 static void list_node( CTX c, KBNODE node );
86 static void proc_tree( CTX c, KBNODE node );
87
88
89 static void
90 release_list( CTX c )
91 {
92     if( !c->list )
93         return;
94     proc_tree(c, c->list );
95     release_kbnode( c->list );
96     while( c->pkenc_list ) {
97         struct kidlist_item *tmp = c->pkenc_list->next;
98         xfree( c->pkenc_list );
99         c->pkenc_list = tmp;
100     }
101     c->pkenc_list = NULL;
102     c->list = NULL;
103     c->have_data = 0;
104     c->last_was_session_key = 0;
105     c->pipemode.op = 0;
106     c->pipemode.stop_now = 0;
107     xfree(c->dek); c->dek = NULL;
108 }
109
110
111 static int
112 add_onepass_sig( CTX c, PACKET *pkt )
113 {
114     KBNODE node;
115
116     if( c->list ) { /* add another packet */
117         /* We can only append another onepass packet if the list
118          * does contain only onepass packets */
119         for( node=c->list; node && node->pkt->pkttype == PKT_ONEPASS_SIG;
120              node = node->next )
121             ;
122         if( node ) {
123             /* this is not the case, so we flush the current thing and 
124              * allow this packet to start a new verification thing */
125            release_list( c );
126            c->list = new_kbnode( pkt );
127         }
128         else
129            add_kbnode( c->list, new_kbnode( pkt ));
130     }
131     else /* insert the first one */
132         c->list = node = new_kbnode( pkt );
133
134     return 1;
135 }
136
137
138 static int
139 add_gpg_control( CTX c, PACKET *pkt )
140 {
141     if ( pkt->pkt.gpg_control->control == CTRLPKT_CLEARSIGN_START ) {
142         /* New clear text signature.
143          * Process the last one and reset everything */
144         release_list(c);
145     }   
146     else if ( pkt->pkt.gpg_control->control == CTRLPKT_PIPEMODE ) {
147         /* Pipemode control packet */
148         if ( pkt->pkt.gpg_control->datalen < 2 ) 
149             log_fatal ("invalid pipemode control packet length\n");
150         if (pkt->pkt.gpg_control->data[0] == 1) {
151             /* start the whole thing */
152             assert ( !c->list ); /* we should be in a pretty virgin state */
153             assert ( !c->pipemode.op );
154             c->pipemode.op = pkt->pkt.gpg_control->data[1];
155         }
156         else if (pkt->pkt.gpg_control->data[0] == 2) {
157             /* the signed material follows in a plaintext packet */
158             assert ( c->pipemode.op == 'B' );
159         }
160         else if (pkt->pkt.gpg_control->data[0] == 3) {
161             assert ( c->pipemode.op == 'B' );
162             release_list (c);
163             /* and tell the outer loop to terminate */
164             c->pipemode.stop_now = 1;
165         }
166         else 
167             log_fatal ("invalid pipemode control packet code\n");
168         return 0; /* no need to store the packet */
169     }   
170
171     if( c->list )  /* add another packet */
172         add_kbnode( c->list, new_kbnode( pkt ));
173     else /* insert the first one */
174         c->list = new_kbnode( pkt );
175
176     return 1;
177 }
178
179
180
181 static int
182 add_user_id( CTX c, PACKET *pkt )
183 {
184     if( !c->list ) {
185         log_error("orphaned user ID\n" );
186         return 0;
187     }
188     add_kbnode( c->list, new_kbnode( pkt ) );
189     return 1;
190 }
191
192 static int
193 add_subkey( CTX c, PACKET *pkt )
194 {
195     if( !c->list ) {
196         log_error("subkey w/o mainkey\n" );
197         return 0;
198     }
199     add_kbnode( c->list, new_kbnode( pkt ) );
200     return 1;
201 }
202
203 static int
204 add_ring_trust( CTX c, PACKET *pkt )
205 {
206     if( !c->list ) {
207         log_error("ring trust w/o key\n" );
208         return 0;
209     }
210     add_kbnode( c->list, new_kbnode( pkt ) );
211     return 1;
212 }
213
214
215 static int
216 add_signature( CTX c, PACKET *pkt )
217 {
218     KBNODE node;
219
220     if( pkt->pkttype == PKT_SIGNATURE && !c->list ) {
221         /* This is the first signature for the following datafile.
222          * GPG does not write such packets; instead it always uses
223          * onepass-sig packets.  The drawback of PGP's method
224          * of prepending the signature to the data is
225          * that it is not possible to make a signature from data read
226          * from stdin.  (GPG is able to read PGP stuff anyway.) */
227         node = new_kbnode( pkt );
228         c->list = node;
229         return 1;
230     }
231     else if( !c->list )
232         return 0; /* oops (invalid packet sequence)*/
233     else if( !c->list->pkt )
234         BUG();  /* so nicht */
235
236     /* add a new signature node id at the end */
237     node = new_kbnode( pkt );
238     add_kbnode( c->list, node );
239     return 1;
240 }
241
242 static int
243 symkey_decrypt_seskey( DEK *dek, byte *seskey, size_t slen )
244 {
245   CIPHER_HANDLE hd;
246
247   if(slen < 17 || slen > 33)
248     {
249       log_error ( _("weird size for an encrypted session key (%d)\n"),
250                   (int)slen);
251       return G10ERR_BAD_KEY;
252     }
253
254   hd = cipher_open( dek->algo, CIPHER_MODE_CFB, 1 );
255   cipher_setkey( hd, dek->key, dek->keylen );
256   cipher_setiv( hd, NULL, 0 );
257   cipher_decrypt( hd, seskey, seskey, slen );
258   cipher_close( hd );
259
260   /* now we replace the dek components with the real session key to
261      decrypt the contents of the sequencing packet. */
262
263   dek->keylen=slen-1;
264   dek->algo=seskey[0];
265
266   if(dek->keylen > DIM(dek->key))
267     BUG ();
268
269   /* This is not completely accurate, since a bad passphrase may have
270      resulted in a garbage algorithm byte, but it's close enough since
271      a bogus byte here will fail later. */
272   if(dek->algo==CIPHER_ALGO_IDEA)
273     idea_cipher_warn(0);
274
275   memcpy(dek->key, seskey + 1, dek->keylen);
276
277   /*log_hexdump( "thekey", dek->key, dek->keylen );*/
278
279   return 0;
280 }   
281
282 static void
283 proc_symkey_enc( CTX c, PACKET *pkt )
284 {
285     PKT_symkey_enc *enc;
286
287     enc = pkt->pkt.symkey_enc;
288     if (!enc)
289         log_error ("invalid symkey encrypted packet\n");
290     else if(!c->dek)
291       {
292         int algo = enc->cipher_algo;
293         const char *s = cipher_algo_to_string (algo);
294
295         if(s)
296           {
297             if(!opt.quiet)
298               {
299                 if(enc->seskeylen)
300                   log_info(_("%s encrypted session key\n"), s );
301                 else
302                   log_info(_("%s encrypted data\n"), s );
303               }
304           }
305         else
306           log_error(_("encrypted with unknown algorithm %d\n"), algo );
307
308         if(check_digest_algo(enc->s2k.hash_algo))
309           {
310             log_error(_("passphrase generated with unknown digest"
311                         " algorithm %d\n"),enc->s2k.hash_algo);
312             s=NULL;
313           }
314
315         c->last_was_session_key = 2;
316         if(!s || opt.list_only)
317           goto leave;
318
319         if(opt.override_session_key)
320           {
321             c->dek = xmalloc_clear( sizeof *c->dek );
322             if(get_override_session_key(c->dek, opt.override_session_key))
323               {
324                 xfree(c->dek);
325                 c->dek = NULL;
326               }
327           }
328         else
329           {
330             c->dek=passphrase_to_dek(NULL, 0, algo, &enc->s2k, 0, NULL, NULL);
331
332             if(c->dek)
333               {
334                 c->dek->symmetric=1;
335
336                 /* FIXME: This doesn't work perfectly if a symmetric
337                    key comes before a public key in the message - if
338                    the user doesn't know the passphrase, then there is
339                    a chance that the "decrypted" algorithm will happen
340                    to be a valid one, which will make the returned dek
341                    appear valid, so we won't try any public keys that
342                    come later. */
343                 if(enc->seskeylen)
344                   {
345                     if(symkey_decrypt_seskey(c->dek, enc->seskey,
346                                              enc->seskeylen))
347                       {
348                         xfree(c->dek);
349                         c->dek=NULL;
350                       }
351                   }
352                 else
353                   c->dek->algo_info_printed = 1;
354               }
355           }
356       }
357
358  leave:
359     c->symkeys++;
360     free_packet(pkt);
361 }
362
363 static void
364 proc_pubkey_enc( CTX c, PACKET *pkt )
365 {
366     PKT_pubkey_enc *enc;
367     int result = 0;
368
369     /* check whether the secret key is available and store in this case */
370     c->last_was_session_key = 1;
371     enc = pkt->pkt.pubkey_enc;
372     /*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
373     /* Hmmm: why do I have this algo check here - anyway there is
374      * function to check it. */
375     if( opt.verbose )
376         log_info(_("public key is %s\n"), keystr(enc->keyid) );
377
378     if( is_status_enabled() ) {
379         char buf[50];
380         sprintf(buf, "%08lX%08lX %d 0",
381                 (ulong)enc->keyid[0], (ulong)enc->keyid[1], enc->pubkey_algo );
382         write_status_text( STATUS_ENC_TO, buf );
383     }
384
385     if( !opt.list_only && opt.override_session_key ) {
386         /* It does not make much sense to store the session key in
387          * secure memory because it has already been passed on the
388          * command line and the GCHQ knows about it */
389         c->dek = xmalloc_clear( sizeof *c->dek );
390         result = get_override_session_key ( c->dek, opt.override_session_key );
391         if ( result ) {
392             xfree(c->dek); c->dek = NULL;
393         }
394     }
395     else if( is_ELGAMAL(enc->pubkey_algo)
396         || enc->pubkey_algo == PUBKEY_ALGO_DSA
397         || is_RSA(enc->pubkey_algo)  ) {
398         if ( !c->dek && ((!enc->keyid[0] && !enc->keyid[1])
399                           || opt.try_all_secrets
400                           || !seckey_available( enc->keyid )) ) {
401             if( opt.list_only )
402                 result = -1;
403             else {
404                 c->dek = xmalloc_secure_clear( sizeof *c->dek );
405                 if( (result = get_session_key( enc, c->dek )) ) {
406                     /* error: delete the DEK */
407                     xfree(c->dek); c->dek = NULL;
408                 }
409             }
410         }
411         else
412             result = G10ERR_NO_SECKEY;
413     }
414     else
415         result = G10ERR_PUBKEY_ALGO;
416
417     if( result == -1 )
418         ;
419     else
420       {
421         /* store it for later display */
422         struct kidlist_item *x = xmalloc( sizeof *x );
423         x->kid[0] = enc->keyid[0];
424         x->kid[1] = enc->keyid[1];
425         x->pubkey_algo = enc->pubkey_algo;
426         x->reason = result;
427         x->next = c->pkenc_list;
428         c->pkenc_list = x;
429
430         if( !result && opt.verbose > 1 )
431           log_info( _("public key encrypted data: good DEK\n") );
432       }
433
434     free_packet(pkt);
435 }
436
437
438
439 /****************
440  * Print the list of public key encrypted packets which we could
441  * not decrypt.
442  */
443 static void
444 print_pkenc_list( struct kidlist_item *list, int failed )
445 {
446     for( ; list; list = list->next ) {
447         PKT_public_key *pk;
448         const char *algstr;
449         
450         if ( failed && !list->reason )
451             continue;
452         if ( !failed && list->reason )
453             continue;
454
455         algstr = pubkey_algo_to_string( list->pubkey_algo );
456         pk = xmalloc_clear( sizeof *pk );
457
458         if( !algstr )
459             algstr = "[?]";
460         pk->pubkey_algo = list->pubkey_algo;
461         if( !get_pubkey( pk, list->kid ) )
462           {
463             char *p;
464             log_info( _("encrypted with %u-bit %s key, ID %s, created %s\n"),
465                       nbits_from_pk( pk ), algstr, keystr_from_pk(pk),
466                       strtimestamp(pk->timestamp) );
467             p=get_user_id_native(list->kid);
468             fprintf(log_stream(),_("      \"%s\"\n"),p);
469             xfree(p);
470           }
471         else
472           log_info(_("encrypted with %s key, ID %s\n"),
473                    algstr,keystr(list->kid));
474
475         free_public_key( pk );
476
477         if( list->reason == G10ERR_NO_SECKEY ) {
478             if( is_status_enabled() ) {
479                 char buf[20];
480                 sprintf(buf,"%08lX%08lX", (ulong)list->kid[0],
481                                           (ulong)list->kid[1] );
482                 write_status_text( STATUS_NO_SECKEY, buf );
483             }
484         }
485         else if (list->reason)
486             log_info(_("public key decryption failed: %s\n"),
487                                                 g10_errstr(list->reason));
488     }
489 }
490
491
492 static void
493 proc_encrypted( CTX c, PACKET *pkt )
494 {
495     int result = 0;
496
497     if (!opt.quiet)
498       {
499         if(c->symkeys>1)
500           log_info(_("encrypted with %lu passphrases\n"),c->symkeys);
501         else if(c->symkeys==1)
502           log_info(_("encrypted with 1 passphrase\n"));
503         print_pkenc_list ( c->pkenc_list, 1 );
504         print_pkenc_list ( c->pkenc_list, 0 );
505       }
506
507     write_status( STATUS_BEGIN_DECRYPTION );
508
509     /*log_debug("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
510     if( opt.list_only )
511         result = -1;
512     else if( !c->dek && !c->last_was_session_key ) {
513         int algo;
514         STRING2KEY s2kbuf, *s2k = NULL;
515
516         if(opt.override_session_key)
517           {
518             c->dek = xmalloc_clear( sizeof *c->dek );
519             result=get_override_session_key(c->dek, opt.override_session_key);
520             if(result)
521               {
522                 xfree(c->dek);
523                 c->dek = NULL;
524               }
525           }
526         else
527           {
528             /* assume this is old style conventional encrypted data */
529             if ( (algo = opt.def_cipher_algo))
530               log_info (_("assuming %s encrypted data\n"),
531                         cipher_algo_to_string(algo));
532             else if ( check_cipher_algo(CIPHER_ALGO_IDEA) )
533               {
534                 algo = opt.def_cipher_algo;
535                 if (!algo)
536                   algo = opt.s2k_cipher_algo;
537                 idea_cipher_warn(1);
538                 log_info (_("IDEA cipher unavailable, "
539                             "optimistically attempting to use %s instead\n"),
540                           cipher_algo_to_string(algo));
541               }
542             else
543               {
544                 algo = CIPHER_ALGO_IDEA;
545                 if (!opt.s2k_digest_algo)
546                   {
547                     /* If no digest is given we assume MD5 */
548                     s2kbuf.mode = 0;
549                     s2kbuf.hash_algo = DIGEST_ALGO_MD5;
550                     s2k = &s2kbuf;
551                   }
552                 log_info (_("assuming %s encrypted data\n"), "IDEA");
553               }
554
555             c->dek = passphrase_to_dek ( NULL, 0, algo, s2k, 0, NULL, NULL );
556             if (c->dek)
557               c->dek->algo_info_printed = 1;
558           }
559     }
560     else if( !c->dek )
561         result = G10ERR_NO_SECKEY;
562     if( !result )
563         result = decrypt_data( c, pkt->pkt.encrypted, c->dek );
564
565     if( result == -1 )
566         ;
567     else if( !result || (result==G10ERR_BAD_SIGN && opt.ignore_mdc_error)) {
568         write_status( STATUS_DECRYPTION_OKAY );
569         if( opt.verbose > 1 )
570             log_info(_("decryption okay\n"));
571         if( pkt->pkt.encrypted->mdc_method && !result )
572             write_status( STATUS_GOODMDC );
573         else if(!opt.no_mdc_warn)
574             log_info (_("WARNING: message was not integrity protected\n"));
575         if(opt.show_session_key)
576           {
577             int i;
578             char *buf = xmalloc ( c->dek->keylen*2 + 20 );
579             sprintf ( buf, "%d:", c->dek->algo );
580             for(i=0; i < c->dek->keylen; i++ )
581               sprintf(buf+strlen(buf), "%02X", c->dek->key[i] );
582             log_info( "session key: `%s'\n", buf );
583             write_status_text ( STATUS_SESSION_KEY, buf );
584           }
585     }
586     else if( result == G10ERR_BAD_SIGN ) {
587         log_error(_("WARNING: encrypted message has been manipulated!\n"));
588         write_status( STATUS_BADMDC );
589         write_status( STATUS_DECRYPTION_FAILED );
590     }
591     else {
592         write_status( STATUS_DECRYPTION_FAILED );
593         log_error(_("decryption failed: %s\n"), g10_errstr(result));
594         /* Hmmm: does this work when we have encrypted using multiple
595          * ways to specify the session key (symmmetric and PK)*/
596     }
597     xfree(c->dek); c->dek = NULL;
598     free_packet(pkt);
599     c->last_was_session_key = 0;
600     write_status( STATUS_END_DECRYPTION );
601 }
602
603
604 static void
605 proc_plaintext( CTX c, PACKET *pkt )
606 {
607     PKT_plaintext *pt = pkt->pkt.plaintext;
608     int any, clearsig, only_md5, rc;
609     KBNODE n;
610
611     if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) )
612         log_info(_("NOTE: sender requested \"for-your-eyes-only\"\n"));
613     else if( opt.verbose )
614         log_info(_("original file name='%.*s'\n"), pt->namelen, pt->name);
615     free_md_filter_context( &c->mfx );
616     c->mfx.md = md_open( 0, 0);
617     /* fixme: we may need to push the textfilter if we have sigclass 1
618      * and no armoring - Not yet tested
619      * Hmmm, why don't we need it at all if we have sigclass 1
620      * Should we assume that plaintext in mode 't' has always sigclass 1??
621      * See: Russ Allbery's mail 1999-02-09
622      */
623     any = clearsig = only_md5 = 0;
624     for(n=c->list; n; n = n->next )
625       {
626         if( n->pkt->pkttype == PKT_ONEPASS_SIG )
627           {
628             /* For the onepass signature case */
629             if( n->pkt->pkt.onepass_sig->digest_algo )
630               {
631                 md_enable( c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo );
632                 if( !any && n->pkt->pkt.onepass_sig->digest_algo
633                     == DIGEST_ALGO_MD5 )
634                   only_md5 = 1;
635                 else
636                   only_md5 = 0;
637                 any = 1;
638               }
639             if( n->pkt->pkt.onepass_sig->sig_class != 0x01 )
640               only_md5 = 0;
641           }
642         else if( n->pkt->pkttype == PKT_GPG_CONTROL
643                  && n->pkt->pkt.gpg_control->control
644                  == CTRLPKT_CLEARSIGN_START )
645           {
646             /* For the clearsigned message case */
647             size_t datalen = n->pkt->pkt.gpg_control->datalen;
648             const byte *data = n->pkt->pkt.gpg_control->data;
649
650             /* check that we have at least the sigclass and one hash */
651             if ( datalen < 2 )
652               log_fatal("invalid control packet CTRLPKT_CLEARSIGN_START\n"); 
653             /* Note that we don't set the clearsig flag for not-dash-escaped
654              * documents */
655             clearsig = (*data == 0x01);
656             for( data++, datalen--; datalen; datalen--, data++ )
657               md_enable( c->mfx.md, *data );
658             any = 1;
659             break;  /* no pass signature packets are expected */
660           }
661         else if(n->pkt->pkttype==PKT_SIGNATURE)
662           {
663             /* For the SIG+LITERAL case that PGP used to use. */
664             md_enable( c->mfx.md, n->pkt->pkt.signature->digest_algo );
665             any=1;
666           }
667       }
668
669     if( !any && !opt.skip_verify )
670       {
671         /* This is for the old GPG LITERAL+SIG case.  It's not legal
672            according to 2440, so hopefully it won't come up that
673            often.  There is no good way to specify what algorithms to
674            use in that case, so these three are the historical
675            answer. */
676         md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
677         md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
678         md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
679       }
680     if( opt.pgp2_workarounds && only_md5 && !opt.skip_verify ) {
681         /* This is a kludge to work around a bug in pgp2.  It does only
682          * catch those mails which are armored.  To catch the non-armored
683          * pgp mails we could see whether there is the signature packet
684          * in front of the plaintext.  If someone needs this, send me a patch.
685          */
686         c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0);
687     }
688     if ( DBG_HASHING ) {
689         md_start_debug( c->mfx.md, "verify" );
690         if ( c->mfx.md2  )
691             md_start_debug( c->mfx.md2, "verify2" );
692     }
693     if ( c->pipemode.op == 'B' )
694         rc = handle_plaintext( pt, &c->mfx, 1, 0 );
695     else {
696         rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
697         if( rc == G10ERR_CREATE_FILE && !c->sigs_only) {
698             /* can't write output but we hash it anyway to
699              * check the signature */
700             rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
701         }
702     }
703     if( rc )
704         log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
705     free_packet(pkt);
706     c->last_was_session_key = 0;
707
708     /* We add a marker control packet instead of the plaintext packet.
709      * This is so that we can later detect invalid packet sequences.
710      */
711     n = new_kbnode (create_gpg_control (CTRLPKT_PLAINTEXT_MARK, NULL, 0));
712     if (c->list)
713         add_kbnode (c->list, n);
714     else 
715         c->list = n;
716 }
717
718
719 static int
720 proc_compressed_cb( IOBUF a, void *info )
721 {
722     return proc_signature_packets( info, a, ((CTX)info)->signed_data,
723                                             ((CTX)info)->sigfilename );
724 }
725
726 static int
727 proc_encrypt_cb( IOBUF a, void *info )
728 {
729     return proc_encryption_packets( info, a );
730 }
731
732 static void
733 proc_compressed( CTX c, PACKET *pkt )
734 {
735     PKT_compressed *zd = pkt->pkt.compressed;
736     int rc;
737
738     /*printf("zip: compressed data packet\n");*/
739     if( c->sigs_only )
740         rc = handle_compressed( c, zd, proc_compressed_cb, c );
741     else if( c->encrypt_only )
742         rc = handle_compressed( c, zd, proc_encrypt_cb, c );
743     else
744         rc = handle_compressed( c, zd, NULL, NULL );
745     if( rc )
746         log_error("uncompressing failed: %s\n", g10_errstr(rc));
747     free_packet(pkt);
748     c->last_was_session_key = 0;
749 }
750
751 /****************
752  * check the signature
753  * Returns: 0 = valid signature or an error code
754  */
755 static int
756 do_check_sig( CTX c, KBNODE node, int *is_selfsig,
757               int *is_expkey, int *is_revkey )
758 {
759     PKT_signature *sig;
760     MD_HANDLE md = NULL, md2 = NULL;
761     int algo, rc;
762
763     assert( node->pkt->pkttype == PKT_SIGNATURE );
764     if( is_selfsig )
765         *is_selfsig = 0;
766     sig = node->pkt->pkt.signature;
767
768     algo = sig->digest_algo;
769     if( (rc=check_digest_algo(algo)) )
770         return rc;
771
772     if( sig->sig_class == 0x00 ) {
773         if( c->mfx.md )
774             md = md_copy( c->mfx.md );
775         else /* detached signature */
776             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
777     }
778     else if( sig->sig_class == 0x01 ) {
779         /* how do we know that we have to hash the (already hashed) text
780          * in canonical mode ??? (calculating both modes???) */
781         if( c->mfx.md ) {
782             md = md_copy( c->mfx.md );
783             if( c->mfx.md2 )
784                md2 = md_copy( c->mfx.md2 );
785         }
786         else { /* detached signature */
787           log_debug("Do we really need this here?");
788             md = md_open( 0, 0 ); /* signature_check() will enable the md*/
789             md2 = md_open( 0, 0 );
790         }
791     }
792     else if( (sig->sig_class&~3) == 0x10
793              || sig->sig_class == 0x18
794              || sig->sig_class == 0x1f
795              || sig->sig_class == 0x20
796              || sig->sig_class == 0x28
797              || sig->sig_class == 0x30  ) { 
798         if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
799             || c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
800             return check_key_signature( c->list, node, is_selfsig );
801         }
802         else if( sig->sig_class == 0x20 ) {
803             log_info(_("standalone revocation - "
804                        "use \"gpg --import\" to apply\n"));
805             return G10ERR_NOT_PROCESSED;
806         }
807         else {
808             log_error("invalid root packet for sigclass %02x\n",
809                                                         sig->sig_class);
810             return G10ERR_SIG_CLASS;
811         }
812     }
813     else
814         return G10ERR_SIG_CLASS;
815     rc = signature_check2( sig, md, NULL, is_expkey, is_revkey, NULL );
816     if( rc == G10ERR_BAD_SIGN && md2 )
817         rc = signature_check2( sig, md2, NULL, is_expkey, is_revkey, NULL );
818     md_close(md);
819     md_close(md2);
820
821     return rc;
822 }
823
824
825 static void
826 print_userid( PACKET *pkt )
827 {
828     if( !pkt )
829         BUG();
830     if( pkt->pkttype != PKT_USER_ID ) {
831         printf("ERROR: unexpected packet type %d", pkt->pkttype );
832         return;
833     }
834     if( opt.with_colons )
835       {
836         if(pkt->pkt.user_id->attrib_data)
837           printf("%u %lu",
838                  pkt->pkt.user_id->numattribs,
839                  pkt->pkt.user_id->attrib_len);
840         else
841           print_string( stdout,  pkt->pkt.user_id->name,
842                         pkt->pkt.user_id->len, ':');
843       }
844     else
845         print_utf8_string( stdout,  pkt->pkt.user_id->name,
846                                      pkt->pkt.user_id->len );
847 }
848
849
850 /****************
851  * List the certificate in a user friendly way
852  */
853
854 static void
855 list_node( CTX c, KBNODE node )
856 {
857     int any=0;
858     int mainkey;
859
860     if( !node )
861         ;
862     else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
863              || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
864         PKT_public_key *pk = node->pkt->pkt.public_key;
865
866         if( opt.with_colons )
867           {
868             u32 keyid[2];
869             keyid_from_pk( pk, keyid );
870             if( mainkey )
871               c->trustletter = opt.fast_list_mode?
872                 0 : get_validity_info( pk, NULL );
873             printf("%s:", mainkey? "pub":"sub" );
874             if( c->trustletter )
875               putchar( c->trustletter );
876             printf(":%u:%d:%08lX%08lX:%s:%s::",
877                    nbits_from_pk( pk ),
878                    pk->pubkey_algo,
879                    (ulong)keyid[0],(ulong)keyid[1],
880                    colon_datestr_from_pk( pk ),
881                    colon_strtime (pk->expiredate) );
882             if( mainkey && !opt.fast_list_mode )
883               putchar( get_ownertrust_info (pk) );
884             putchar(':');
885             if( node->next && node->next->pkt->pkttype == PKT_RING_TRUST) {
886               putchar('\n'); any=1;
887               if( opt.fingerprint )
888                 print_fingerprint( pk, NULL, 0 );
889               printf("rtv:1:%u:\n",
890                      node->next->pkt->pkt.ring_trust->trustval );
891             }
892           }
893         else
894           printf("%s  %4u%c/%s %s%s",
895                  mainkey? "pub":"sub", nbits_from_pk( pk ),
896                  pubkey_letter( pk->pubkey_algo ), keystr_from_pk( pk ),
897                  datestr_from_pk( pk ), mainkey?" ":"");
898
899         if( mainkey ) {
900             /* and now list all userids with their signatures */
901             for( node = node->next; node; node = node->next ) {
902                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
903                     if( !any ) {
904                         if( node->pkt->pkt.signature->sig_class == 0x20 )
905                             puts("[revoked]");
906                         else
907                             putchar('\n');
908                         any = 1;
909                     }
910                     list_node(c,  node );
911                 }
912                 else if( node->pkt->pkttype == PKT_USER_ID ) {
913                     if( any ) {
914                         if( opt.with_colons )
915                             printf("%s:::::::::",
916                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
917                         else
918                             printf( "uid%*s", 28, "" );
919                     }
920                     print_userid( node->pkt );
921                     if( opt.with_colons )
922                         putchar(':');
923                     putchar('\n');
924                     if( opt.fingerprint && !any )
925                         print_fingerprint( pk, NULL, 0 );
926                     if( node->next
927                         && node->next->pkt->pkttype == PKT_RING_TRUST ) {
928                         printf("rtv:2:%u:\n",
929                                  node->next->pkt->pkt.ring_trust->trustval );
930                     }
931                     any=1;
932                 }
933                 else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
934                     if( !any ) {
935                         putchar('\n');
936                         any = 1;
937                     }
938                     list_node(c,  node );
939                 }
940             }
941         }
942         else
943           {
944             /* of subkey */
945             if( pk->is_revoked )
946               {
947                 printf(" [");
948                 printf(_("revoked: %s"),revokestr_from_pk(pk));
949                 printf("]");
950               }
951             else if( pk->expiredate )
952               {
953                 printf(" [");
954                 printf(_("expires: %s"),expirestr_from_pk(pk));
955                 printf("]");
956               }
957           }
958
959         if( !any )
960             putchar('\n');
961         if( !mainkey && opt.fingerprint > 1 )
962             print_fingerprint( pk, NULL, 0 );
963     }
964     else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
965              || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
966         PKT_secret_key *sk = node->pkt->pkt.secret_key;
967
968         if( opt.with_colons )
969           {
970             u32 keyid[2];
971             keyid_from_sk( sk, keyid );
972             printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
973                    mainkey? "sec":"ssb",
974                    nbits_from_sk( sk ),
975                    sk->pubkey_algo,
976                    (ulong)keyid[0],(ulong)keyid[1],
977                    colon_datestr_from_sk( sk ),
978                    colon_strtime (sk->expiredate)
979                    /* fixme: add LID */ );
980           }
981         else
982           printf("%s  %4u%c/%s %s ", mainkey? "sec":"ssb",
983                  nbits_from_sk( sk ), pubkey_letter( sk->pubkey_algo ),
984                  keystr_from_sk( sk ), datestr_from_sk( sk ));
985         if( mainkey ) {
986             /* and now list all userids with their signatures */
987             for( node = node->next; node; node = node->next ) {
988                 if( node->pkt->pkttype == PKT_SIGNATURE ) {
989                     if( !any ) {
990                         if( node->pkt->pkt.signature->sig_class == 0x20 )
991                             puts("[revoked]");
992                         else
993                             putchar('\n');
994                         any = 1;
995                     }
996                     list_node(c,  node );
997                 }
998                 else if( node->pkt->pkttype == PKT_USER_ID ) {
999                     if( any ) {
1000                         if( opt.with_colons )
1001                             printf("%s:::::::::",
1002                               node->pkt->pkt.user_id->attrib_data?"uat":"uid");
1003                         else
1004                             printf( "uid%*s", 28, "" );
1005                     }
1006                     print_userid( node->pkt );
1007                     if( opt.with_colons )
1008                         putchar(':');
1009                     putchar('\n');
1010                     if( opt.fingerprint && !any )
1011                         print_fingerprint( NULL, sk, 0 );
1012                     any=1;
1013                 }
1014                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1015                     if( !any ) {
1016                         putchar('\n');
1017                         any = 1;
1018                     }
1019                     list_node(c,  node );
1020                 }
1021             }
1022         }
1023         if( !any )
1024             putchar('\n');
1025         if( !mainkey && opt.fingerprint > 1 )
1026             print_fingerprint( NULL, sk, 0 );
1027     }
1028     else if( node->pkt->pkttype == PKT_SIGNATURE  ) {
1029         PKT_signature *sig = node->pkt->pkt.signature;
1030         int is_selfsig = 0;
1031         int rc2=0;
1032         size_t n;
1033         char *p;
1034         int sigrc = ' ';
1035
1036         if( !opt.verbose )
1037             return;
1038
1039         if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
1040             fputs("rev", stdout);
1041         else
1042             fputs("sig", stdout);
1043         if( opt.check_sigs ) {
1044             fflush(stdout);
1045             switch( (rc2=do_check_sig( c, node, &is_selfsig, NULL, NULL )) ) {
1046               case 0:                  sigrc = '!'; break;
1047               case G10ERR_BAD_SIGN:    sigrc = '-'; break;
1048               case G10ERR_NO_PUBKEY: 
1049               case G10ERR_UNU_PUBKEY:  sigrc = '?'; break;
1050               default:                 sigrc = '%'; break;
1051             }
1052         }
1053         else {  /* check whether this is a self signature */
1054             u32 keyid[2];
1055
1056             if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
1057                 || c->list->pkt->pkttype == PKT_SECRET_KEY ) {
1058                 if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
1059                     keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
1060                 else
1061                     keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
1062
1063                 if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
1064                     is_selfsig = 1;
1065             }
1066         }
1067         if( opt.with_colons ) {
1068             putchar(':');
1069             if( sigrc != ' ' )
1070                 putchar(sigrc);
1071             printf("::%d:%08lX%08lX:%s:%s:", sig->pubkey_algo,
1072                    (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1073                    colon_datestr_from_sig(sig),
1074                    colon_expirestr_from_sig(sig));
1075
1076             if(sig->trust_depth || sig->trust_value)
1077               printf("%d %d",sig->trust_depth,sig->trust_value);
1078             printf(":");
1079
1080             if(sig->trust_regexp)
1081               print_string(stdout,sig->trust_regexp,
1082                            strlen(sig->trust_regexp),':');
1083             printf(":");
1084         }
1085         else
1086           printf("%c       %s %s   ",
1087                  sigrc, keystr(sig->keyid), datestr_from_sig(sig));
1088         if( sigrc == '%' )
1089             printf("[%s] ", g10_errstr(rc2) );
1090         else if( sigrc == '?' )
1091             ;
1092         else if( is_selfsig ) {
1093             if( opt.with_colons )
1094                 putchar(':');
1095             fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
1096             if( opt.with_colons )
1097                 putchar(':');
1098         }
1099         else if( !opt.fast_list_mode ) {
1100             p = get_user_id( sig->keyid, &n );
1101             print_string( stdout, p, n, opt.with_colons );
1102             xfree(p);
1103         }
1104         if( opt.with_colons )
1105             printf(":%02x%c:", sig->sig_class, sig->flags.exportable?'x':'l');
1106         putchar('\n');
1107     }
1108     else
1109         log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
1110 }
1111
1112
1113
1114 int
1115 proc_packets( void *anchor, IOBUF a )
1116 {
1117     int rc;
1118     CTX c = xmalloc_clear( sizeof *c );
1119
1120     c->anchor = anchor;
1121     rc = do_proc_packets( c, a );
1122     xfree( c );
1123     return rc;
1124 }
1125
1126
1127
1128 int
1129 proc_signature_packets( void *anchor, IOBUF a,
1130                         STRLIST signedfiles, const char *sigfilename )
1131 {
1132     CTX c = xmalloc_clear( sizeof *c );
1133     int rc;
1134
1135     c->anchor = anchor;
1136     c->sigs_only = 1;
1137     c->signed_data = signedfiles;
1138     c->sigfilename = sigfilename;
1139     rc = do_proc_packets( c, a );
1140     xfree( c );
1141     return rc;
1142 }
1143
1144 int
1145 proc_encryption_packets( void *anchor, IOBUF a )
1146 {
1147     CTX c = xmalloc_clear( sizeof *c );
1148     int rc;
1149
1150     c->anchor = anchor;
1151     c->encrypt_only = 1;
1152     rc = do_proc_packets( c, a );
1153     xfree( c );
1154     return rc;
1155 }
1156
1157
1158 int
1159 do_proc_packets( CTX c, IOBUF a )
1160 {
1161     PACKET *pkt = xmalloc( sizeof *pkt );
1162     int rc=0;
1163     int any_data=0;
1164     int newpkt;
1165
1166     c->iobuf = a;
1167     init_packet(pkt);
1168     while( (rc=parse_packet(a, pkt)) != -1 ) {
1169         any_data = 1;
1170         if( rc ) {
1171             free_packet(pkt);
1172             /* stop processing when an invalid packet has been encountered
1173              * but don't do so when we are doing a --list-packets. */
1174             if( rc == G10ERR_INVALID_PACKET && opt.list_packets != 2 )
1175                 break;
1176             continue;
1177         }
1178         newpkt = -1;
1179         if( opt.list_packets ) {
1180             switch( pkt->pkttype ) {
1181               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1182               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1183               case PKT_ENCRYPTED:
1184               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1185               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1186               default: newpkt = 0; break;
1187             }
1188         }
1189         else if( c->sigs_only ) {
1190             switch( pkt->pkttype ) {
1191               case PKT_PUBLIC_KEY:
1192               case PKT_SECRET_KEY:
1193               case PKT_USER_ID:
1194               case PKT_SYMKEY_ENC:
1195               case PKT_PUBKEY_ENC:
1196               case PKT_ENCRYPTED:
1197               case PKT_ENCRYPTED_MDC:
1198                 write_status_text( STATUS_UNEXPECTED, "0" );
1199                 rc = G10ERR_UNEXPECTED;
1200                 goto leave;
1201               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1202               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1203               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1204               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1205               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1206               default: newpkt = 0; break;
1207             }
1208         }
1209         else if( c->encrypt_only ) {
1210             switch( pkt->pkttype ) {
1211               case PKT_PUBLIC_KEY:
1212               case PKT_SECRET_KEY:
1213               case PKT_USER_ID:
1214                 write_status_text( STATUS_UNEXPECTED, "0" );
1215                 rc = G10ERR_UNEXPECTED;
1216                 goto leave;
1217               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1218               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1219               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1220               case PKT_ENCRYPTED:
1221               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1222               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1223               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1224               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1225               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1226               default: newpkt = 0; break;
1227             }
1228         }
1229         else {
1230             switch( pkt->pkttype ) {
1231               case PKT_PUBLIC_KEY:
1232               case PKT_SECRET_KEY:
1233                 release_list( c );
1234                 c->list = new_kbnode( pkt );
1235                 newpkt = 1;
1236                 break;
1237               case PKT_PUBLIC_SUBKEY:
1238               case PKT_SECRET_SUBKEY:
1239                 newpkt = add_subkey( c, pkt );
1240                 break;
1241               case PKT_USER_ID:     newpkt = add_user_id( c, pkt ); break;
1242               case PKT_SIGNATURE:   newpkt = add_signature( c, pkt ); break;
1243               case PKT_PUBKEY_ENC:  proc_pubkey_enc( c, pkt ); break;
1244               case PKT_SYMKEY_ENC:  proc_symkey_enc( c, pkt ); break;
1245               case PKT_ENCRYPTED:
1246               case PKT_ENCRYPTED_MDC: proc_encrypted( c, pkt ); break;
1247               case PKT_PLAINTEXT:   proc_plaintext( c, pkt ); break;
1248               case PKT_COMPRESSED:  proc_compressed( c, pkt ); break;
1249               case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
1250               case PKT_GPG_CONTROL: newpkt = add_gpg_control(c, pkt); break;
1251               case PKT_RING_TRUST:  newpkt = add_ring_trust( c, pkt ); break;
1252               default: newpkt = 0; break;
1253             }
1254         }
1255         /* This is a very ugly construct and frankly, I don't remember why
1256          * I used it.  Adding the MDC check here is a hack.
1257          * The right solution is to initiate another context for encrypted
1258          * packet and not to reuse the current one ...  It works right
1259          * when there is a compression packet inbetween which adds just
1260          * an extra layer.
1261          * Hmmm: Rewrite this whole module here?? 
1262          */
1263         if( pkt->pkttype != PKT_SIGNATURE && pkt->pkttype != PKT_MDC )
1264             c->have_data = pkt->pkttype == PKT_PLAINTEXT;
1265
1266         if( newpkt == -1 )
1267             ;
1268         else if( newpkt ) {
1269             pkt = xmalloc( sizeof *pkt );
1270             init_packet(pkt);
1271         }
1272         else
1273             free_packet(pkt);
1274         if ( c->pipemode.stop_now ) {
1275             /* we won't get an EOF in pipemode, so we have to 
1276              * break the loop here */ 
1277             rc = -1;
1278             break;
1279         }
1280     }
1281     if( rc == G10ERR_INVALID_PACKET )
1282         write_status_text( STATUS_NODATA, "3" );
1283     if( any_data )
1284         rc = 0;
1285     else if( rc == -1 )
1286         write_status_text( STATUS_NODATA, "2" );
1287
1288
1289   leave:
1290     release_list( c );
1291     xfree(c->dek);
1292     free_packet( pkt );
1293     xfree( pkt );
1294     free_md_filter_context( &c->mfx );
1295     return rc;
1296 }
1297
1298
1299 /* Helper for pka_uri_from_sig to parse the to-be-verified address out
1300    of the notation data. */
1301 static pka_info_t *
1302 get_pka_address (PKT_signature *sig)
1303 {
1304   const unsigned char *p;
1305   size_t len, n1, n2;
1306   int seq = 0;
1307   pka_info_t *pka = NULL;
1308
1309   while ((p = enum_sig_subpkt (sig->hashed, SIGSUBPKT_NOTATION,
1310                                &len, &seq, NULL)))
1311     {
1312       if (len < 8)
1313         continue; /* Notation packet is too short. */
1314       n1 = (p[4]<<8)|p[5];
1315       n2 = (p[6]<<8)|p[7];
1316       if (8 + n1 + n2 != len)
1317         continue; /* Length fields of notation packet are inconsistent. */
1318       p += 8;
1319       if (n1 != 21 || memcmp (p, "pka-address@gnupg.org", 21))
1320         continue; /* Not the notation we want. */
1321       p += n1;
1322       if (n2 < 3)
1323         continue; /* Impossible email address. */
1324
1325       if (pka)
1326         break; /* For now we only use the first valid PKA notation. In
1327                   future we might want to keep additional PKA
1328                   notations in a linked list. */
1329
1330       pka = xmalloc (sizeof *pka + n2);
1331       pka->valid = 0;
1332       pka->checked = 0;
1333       pka->uri = NULL;
1334       memcpy (pka->email, p, n2);
1335       pka->email[n2] = 0;
1336
1337       if (!is_valid_mailbox (pka->email))
1338         {
1339           /* We don't accept invalid mail addresses. */
1340           xfree (pka);
1341           pka = NULL;
1342         }
1343     }
1344
1345   return pka;
1346 }
1347
1348
1349 /* Return the URI from a DNS PKA record.  If this record has already
1350    be retrieved for the signature we merely return it; if not we go
1351    out and try to get that DNS record. */
1352 static const char *
1353 pka_uri_from_sig (PKT_signature *sig)
1354 {
1355   if (!sig->flags.pka_tried)
1356     {
1357       assert (!sig->pka_info);
1358       sig->flags.pka_tried = 1;
1359       sig->pka_info = get_pka_address (sig);
1360       if (sig->pka_info)
1361         {
1362           char *uri;
1363
1364           uri = get_pka_info (sig->pka_info->email, sig->pka_info->fpr);
1365           if (uri)
1366             {
1367               sig->pka_info->valid = 1;
1368               if (!*uri)
1369                 xfree (uri);
1370               else
1371                 sig->pka_info->uri = uri;
1372             }
1373         }
1374     }
1375   return sig->pka_info? sig->pka_info->uri : NULL;
1376 }
1377
1378
1379 static int
1380 check_sig_and_print( CTX c, KBNODE node )
1381 {
1382     PKT_signature *sig = node->pkt->pkt.signature;
1383     const char *astr;
1384     int rc, is_expkey=0, is_revkey=0;
1385
1386     if( opt.skip_verify ) {
1387         log_info(_("signature verification suppressed\n"));
1388         return 0;
1389     }
1390
1391     /* It is not in all cases possible to check multiple signatures:
1392      * PGP 2 (which is also allowed by OpenPGP), does use the packet
1393      * sequence: sig+data,  OpenPGP does use onepas+data=sig and GnuPG
1394      * sometimes uses (because I did'nt read the specs right) data+sig.
1395      * Because it is possible to create multiple signatures with
1396      * different packet sequence (e.g. data+sig and sig+data) it might
1397      * not be possible to get it right:  let's say we have:
1398      * data+sig, sig+data,sig+data and we have not yet encountered the last
1399      * data, we could also see this a one data with 2 signatures and then 
1400      * data+sig.
1401      * To protect against this we check that all signatures follow
1402      * without any intermediate packets.  Note, that we won't get this
1403      * error when we use onepass packets or cleartext signatures because
1404      * we reset the list every time
1405      *
1406      * FIXME: Now that we have these marker packets, we should create a 
1407      * real grammar and check against this.
1408      */
1409     {
1410         KBNODE n;
1411         int n_sig=0;
1412
1413         for (n=c->list; n; n=n->next ) {
1414             if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1415                 n_sig++;
1416         }
1417         if (n_sig > 1) { /* more than one signature - check sequence */
1418             int tmp, onepass;
1419
1420             for (tmp=onepass=0,n=c->list; n; n=n->next ) {
1421                 if (n->pkt->pkttype == PKT_ONEPASS_SIG) 
1422                     onepass++;
1423                 else if (n->pkt->pkttype == PKT_GPG_CONTROL
1424                          && n->pkt->pkt.gpg_control->control
1425                             == CTRLPKT_CLEARSIGN_START ) {
1426                     onepass++; /* handle the same way as a onepass */
1427                 }
1428                 else if ( (tmp && n->pkt->pkttype != PKT_SIGNATURE) ) {
1429                     log_error(_("can't handle these multiple signatures\n"));
1430                     return 0;
1431                 }
1432                 else if ( n->pkt->pkttype == PKT_SIGNATURE ) 
1433                     tmp = 1;
1434                 else if (!tmp && !onepass 
1435                          && n->pkt->pkttype == PKT_GPG_CONTROL
1436                          && n->pkt->pkt.gpg_control->control
1437                             == CTRLPKT_PLAINTEXT_MARK ) {
1438                     /* plaintext before signatures but no one-pass packets*/
1439                     log_error(_("can't handle these multiple signatures\n"));
1440                     return 0;
1441                 }
1442             }
1443         }
1444     }
1445
1446     astr = pubkey_algo_to_string( sig->pubkey_algo );
1447     if(keystrlen()>8)
1448       {
1449         log_info(_("Signature made %s\n"),asctimestamp(sig->timestamp));
1450         log_info(_("               using %s key %s\n"),
1451                  astr? astr: "?",keystr(sig->keyid));
1452       }
1453     else
1454       log_info(_("Signature made %s using %s key ID %s\n"),
1455                asctimestamp(sig->timestamp), astr? astr: "?",
1456                keystr(sig->keyid));
1457
1458     rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1459
1460     /* If the key isn't found, check for a preferred keyserver */
1461
1462     if(rc==G10ERR_NO_PUBKEY && sig->flags.pref_ks)
1463       {
1464         const byte *p;
1465         int seq=0;
1466         size_t n;
1467
1468         while((p=enum_sig_subpkt(sig->hashed,SIGSUBPKT_PREF_KS,&n,&seq,NULL)))
1469           {
1470             /* According to my favorite copy editor, in English
1471                grammar, you say "at" if the key is located on a web
1472                page, but "from" if it is located on a keyserver.  I'm
1473                not going to even try to make two strings here :) */
1474             log_info(_("Key available at: ") );
1475             print_utf8_string( log_stream(), p, n );
1476             putc( '\n', log_stream() );
1477
1478             if(opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE
1479                && opt.keyserver_options.options&KEYSERVER_HONOR_KEYSERVER_URL)
1480               {
1481                 struct keyserver_spec *spec;
1482
1483                 spec=parse_preferred_keyserver(sig);
1484                 if(spec)
1485                   {
1486                     int res;
1487
1488                     glo_ctrl.in_auto_key_retrieve++;
1489                     res=keyserver_import_keyid(sig->keyid,spec);
1490                     glo_ctrl.in_auto_key_retrieve--;
1491                     if(!res)
1492                       rc=do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1493                     free_keyserver_spec(spec);
1494
1495                     if(!rc)
1496                       break;
1497                   }
1498               }
1499           }
1500       }
1501
1502
1503     /* If the preferred keyserver thing above didn't work, our second
1504        try is to use the URI from a DNS PKA record. */
1505     if ( rc == G10ERR_NO_PUBKEY 
1506          && (opt.keyserver_options.options&KEYSERVER_AUTO_PKA_RETRIEVE))
1507       {
1508         const char *uri = pka_uri_from_sig (sig);
1509         
1510         if (uri)
1511           {
1512             /* FIXME: We might want to locate the key using the
1513                fingerprint instead of the keyid. */
1514             int res;
1515             struct keyserver_spec *spec;
1516             
1517             spec = parse_keyserver_uri (uri, 0, NULL, 0);
1518             if (spec)
1519               {
1520                 glo_ctrl.in_auto_key_retrieve++;
1521                 res = keyserver_import_keyid (sig->keyid, spec);
1522                 glo_ctrl.in_auto_key_retrieve--;
1523                 free_keyserver_spec (spec);
1524                 if (!res)
1525                   rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1526               }
1527           }
1528       }
1529
1530
1531     /* If the preferred keyserver thing above didn't work and we got
1532        no information from the DNS PKA, this is a third try. */
1533
1534     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1535         && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
1536       {
1537         int res;
1538
1539         glo_ctrl.in_auto_key_retrieve++;
1540         res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
1541         glo_ctrl.in_auto_key_retrieve--;
1542         if(!res)
1543           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1544       }
1545
1546     if( !rc || rc == G10ERR_BAD_SIGN ) {
1547         KBNODE un, keyblock;
1548         int count=0, statno;
1549         char keyid_str[50];
1550         PKT_public_key *pk=NULL;
1551
1552         if(rc)
1553           statno=STATUS_BADSIG;
1554         else if(sig->flags.expired)
1555           statno=STATUS_EXPSIG;
1556         else if(is_expkey)
1557           statno=STATUS_EXPKEYSIG;
1558         else if(is_revkey)
1559           statno=STATUS_REVKEYSIG;
1560         else
1561           statno=STATUS_GOODSIG;
1562
1563         keyblock = get_pubkeyblock( sig->keyid );
1564
1565         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1566                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1567
1568         /* find and print the primary user ID */
1569         for( un=keyblock; un; un = un->next ) {
1570             char *p;
1571             int valid;
1572             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1573               {
1574                 pk=un->pkt->pkt.public_key;
1575                 continue;
1576               }
1577             if( un->pkt->pkttype != PKT_USER_ID )
1578                 continue;
1579             if ( !un->pkt->pkt.user_id->created )
1580                 continue;
1581             if ( un->pkt->pkt.user_id->is_revoked )
1582                 continue;
1583             if ( un->pkt->pkt.user_id->is_expired )
1584                 continue;
1585             if ( !un->pkt->pkt.user_id->is_primary )
1586                 continue;
1587             /* We want the textual primary user ID here */
1588             if ( un->pkt->pkt.user_id->attrib_data )
1589                 continue;
1590
1591             assert(pk);
1592
1593             /* Get it before we print anything to avoid interrupting
1594                the output with the "please do a --check-trustdb"
1595                line. */
1596             valid=get_validity(pk,un->pkt->pkt.user_id);
1597
1598             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1599             write_status_text_and_buffer (statno, keyid_str,
1600                                           un->pkt->pkt.user_id->name,
1601                                           un->pkt->pkt.user_id->len, 
1602                                           -1 );
1603
1604             p=utf8_to_native(un->pkt->pkt.user_id->name,
1605                              un->pkt->pkt.user_id->len,0);
1606
1607             if(rc)
1608               log_info(_("BAD signature from \"%s\""),p);
1609             else if(sig->flags.expired)
1610               log_info(_("Expired signature from \"%s\""),p);
1611             else
1612               log_info(_("Good signature from \"%s\""),p);
1613
1614             xfree(p);
1615
1616             if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1617               fprintf(log_stream()," [%s]\n",trust_value_to_string(valid));
1618             else
1619               fputs("\n", log_stream() );
1620             count++;
1621         }
1622         if( !count ) {  /* just in case that we have no valid textual
1623                            userid */
1624             char *p;
1625
1626             /* Try for an invalid textual userid */
1627             for( un=keyblock; un; un = un->next ) {
1628                 if( un->pkt->pkttype == PKT_USER_ID &&
1629                     !un->pkt->pkt.user_id->attrib_data )
1630                     break;
1631             }
1632
1633             /* Try for any userid at all */
1634             if(!un) {
1635                 for( un=keyblock; un; un = un->next ) {
1636                     if( un->pkt->pkttype == PKT_USER_ID )
1637                         break;
1638                 }
1639             }
1640
1641             if (opt.trust_model==TM_ALWAYS || !un)
1642                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1643
1644             write_status_text_and_buffer (statno, keyid_str,
1645                                           un? un->pkt->pkt.user_id->name:"[?]",
1646                                           un? un->pkt->pkt.user_id->len:3, 
1647                                           -1 );
1648
1649             if(un)
1650               p=utf8_to_native(un->pkt->pkt.user_id->name,
1651                                un->pkt->pkt.user_id->len,0);
1652             else
1653               p=xstrdup("[?]");
1654
1655             if(rc)
1656               log_info(_("BAD signature from \"%s\""),p);
1657             else if(sig->flags.expired)
1658               log_info(_("Expired signature from \"%s\""),p);
1659             else
1660               log_info(_("Good signature from \"%s\""),p);
1661             if (opt.trust_model!=TM_ALWAYS && un)
1662               {
1663                 putc(' ', log_stream() );
1664                 fputs(_("[uncertain]"), log_stream() );
1665               }
1666             fputs("\n", log_stream() );
1667         }
1668
1669         /* If we have a good signature and already printed 
1670          * the primary user ID, print all the other user IDs */
1671         if ( count && !rc ) {
1672             char *p;
1673             for( un=keyblock; un; un = un->next ) {
1674                 if( un->pkt->pkttype != PKT_USER_ID )
1675                     continue;
1676                 if((un->pkt->pkt.user_id->is_revoked
1677                     || un->pkt->pkt.user_id->is_expired)
1678                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1679                   continue;
1680                 /* Only skip textual primaries */
1681                 if ( un->pkt->pkt.user_id->is_primary &&
1682                      !un->pkt->pkt.user_id->attrib_data )
1683                     continue;
1684
1685                 if(un->pkt->pkt.user_id->attrib_data)
1686                   {
1687                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1688
1689                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1690                       show_photos(un->pkt->pkt.user_id->attribs,
1691                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1692                   }
1693
1694                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1695                                  un->pkt->pkt.user_id->len,0);
1696                 log_info(_("                aka \"%s\""),p);
1697                 xfree(p);
1698
1699                 if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1700                   {
1701                     const char *valid;
1702                     if(un->pkt->pkt.user_id->is_revoked)
1703                       valid=_("revoked");
1704                     else if(un->pkt->pkt.user_id->is_expired)
1705                       valid=_("expired");
1706                     else
1707                       valid=trust_value_to_string(get_validity(pk,
1708                                                                un->pkt->
1709                                                                pkt.user_id));
1710                     fprintf(log_stream()," [%s]\n",valid);
1711                   }
1712                 else
1713                   fputs("\n", log_stream() );
1714             }
1715         }
1716         release_kbnode( keyblock );
1717
1718         if( !rc )
1719           {
1720             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1721               show_policy_url(sig,0,1);
1722             else
1723               show_policy_url(sig,0,2);
1724
1725             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1726               show_keyserver_url(sig,0,1);
1727             else
1728               show_keyserver_url(sig,0,2);
1729
1730             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1731               show_notation(sig,0,1,
1732                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1733                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1734             else
1735               show_notation(sig,0,2,0);
1736           }
1737
1738         if( !rc && is_status_enabled() ) {
1739             /* print a status response with the fingerprint */
1740             PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
1741
1742             if( !get_pubkey( vpk, sig->keyid ) ) {
1743                 byte array[MAX_FINGERPRINT_LEN], *p;
1744                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1745                 size_t i, n;
1746
1747                 bufp = buf;
1748                 fingerprint_from_pk( vpk, array, &n );
1749                 p = array;
1750                 for(i=0; i < n ; i++, p++, bufp += 2)
1751                     sprintf(bufp, "%02X", *p );
1752                 /* TODO: Replace the reserved '0' in the field below
1753                    with bits for status flags (policy url, notation,
1754                    etc.).  Remember to make the buffer larger to
1755                    match! */
1756                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1757                         strtimestamp( sig->timestamp ),
1758                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1759                         sig->version,sig->pubkey_algo,sig->digest_algo,
1760                         sig->sig_class);
1761                 bufp = bufp + strlen (bufp);
1762                 if (!vpk->is_primary) {
1763                    u32 akid[2];
1764  
1765                    akid[0] = vpk->main_keyid[0];
1766                    akid[1] = vpk->main_keyid[1];
1767                    free_public_key (vpk);
1768                    vpk = xmalloc_clear( sizeof *vpk );
1769                    if (get_pubkey (vpk, akid)) {
1770                      /* impossible error, we simply return a zeroed out fpr */
1771                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1772                      memset (array, 0, n);
1773                    }
1774                    else
1775                      fingerprint_from_pk( vpk, array, &n );
1776                 }
1777                 p = array;
1778                 for(i=0; i < n ; i++, p++, bufp += 2)
1779                     sprintf(bufp, "%02X", *p );
1780                 write_status_text( STATUS_VALIDSIG, buf );
1781             }
1782             free_public_key( vpk );
1783         }
1784
1785         if (!rc)
1786           {
1787             pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1788             rc = check_signatures_trust( sig );
1789           }
1790
1791         if(sig->flags.expired)
1792           {
1793             log_info(_("Signature expired %s\n"),
1794                      asctimestamp(sig->expiredate));
1795             rc=G10ERR_GENERAL; /* need a better error here? */
1796           }
1797         else if(sig->expiredate)
1798           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1799
1800         if(opt.verbose)
1801           log_info(_("%s signature, digest algorithm %s\n"),
1802                    sig->sig_class==0x00?_("binary"):
1803                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1804                    digest_algo_to_string(sig->digest_algo));
1805
1806         if( rc )
1807             g10_errors_seen = 1;
1808         if( opt.batch && rc )
1809             g10_exit(1);
1810     }
1811     else {
1812         char buf[50];
1813         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1814                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1815                      sig->pubkey_algo, sig->digest_algo,
1816                      sig->sig_class, (ulong)sig->timestamp, rc );
1817         write_status_text( STATUS_ERRSIG, buf );
1818         if( rc == G10ERR_NO_PUBKEY ) {
1819             buf[16] = 0;
1820             write_status_text( STATUS_NO_PUBKEY, buf );
1821         }
1822         if( rc != G10ERR_NOT_PROCESSED )
1823             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1824     }
1825     return rc;
1826 }
1827
1828
1829 /****************
1830  * Process the tree which starts at node
1831  */
1832 static void
1833 proc_tree( CTX c, KBNODE node )
1834 {
1835     KBNODE n1;
1836     int rc;
1837
1838     if( opt.list_packets || opt.list_only )
1839         return;
1840
1841     /* we must skip our special plaintext marker packets here becuase
1842        they may be the root packet.  These packets are only used in
1843        addionla checks and skipping them here doesn't matter */
1844     while ( node
1845             && node->pkt->pkttype == PKT_GPG_CONTROL
1846             && node->pkt->pkt.gpg_control->control
1847                          == CTRLPKT_PLAINTEXT_MARK ) {
1848         node = node->next;
1849     }
1850     if (!node)
1851         return;
1852
1853     c->trustletter = ' ';
1854     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1855         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1856         merge_keys_and_selfsig( node );
1857         list_node( c, node );
1858     }
1859     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1860         merge_keys_and_selfsig( node );
1861         list_node( c, node );
1862     }
1863     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1864         /* check all signatures */
1865         if( !c->have_data ) {
1866             free_md_filter_context( &c->mfx );
1867             /* prepare to create all requested message digests */
1868             c->mfx.md = md_open(0, 0);
1869
1870             /* fixme: why looking for the signature packet and not 1passpacket*/
1871             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1872                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1873             }
1874             /* ask for file and hash it */
1875             if( c->sigs_only ) {
1876                 rc = hash_datafiles( c->mfx.md, NULL,
1877                                      c->signed_data, c->sigfilename,
1878                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1879             }
1880             else {
1881                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1882                                                 iobuf_get_real_fname(c->iobuf),
1883                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1884             }
1885             if( rc ) {
1886                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1887                 return;
1888             }
1889         }
1890         else if ( c->signed_data ) {
1891             log_error (_("not a detached signature\n") );
1892             return;
1893         }
1894
1895         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1896             check_sig_and_print( c, n1 );
1897     }
1898     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1899              && node->pkt->pkt.gpg_control->control
1900                 == CTRLPKT_CLEARSIGN_START ) {
1901         /* clear text signed message */
1902         if( !c->have_data ) {
1903             log_error("cleartext signature without data\n" );
1904             return;
1905         }
1906         else if ( c->signed_data ) {
1907             log_error (_("not a detached signature\n") );
1908             return;
1909         }
1910         
1911         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1912             check_sig_and_print( c, n1 );
1913     }
1914     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1915         PKT_signature *sig = node->pkt->pkt.signature;
1916         int multiple_ok=1;
1917
1918         n1=find_next_kbnode(node, PKT_SIGNATURE);
1919         if(n1)
1920           {
1921             byte class=sig->sig_class;
1922             byte hash=sig->digest_algo;
1923
1924             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1925               {
1926                 /* We can't currently handle multiple signatures of
1927                    different classes or digests (we'd pretty much have
1928                    to run a different hash context for each), but if
1929                    they are all the same, make an exception. */
1930                 if(n1->pkt->pkt.signature->sig_class!=class
1931                    || n1->pkt->pkt.signature->digest_algo!=hash)
1932                   {
1933                     multiple_ok=0;
1934                     log_info(_("WARNING: multiple signatures detected.  "
1935                                "Only the first will be checked.\n"));
1936                     break;
1937                   }
1938               }
1939           }
1940
1941         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1942             log_info(_("standalone signature of class 0x%02x\n"),
1943                                                     sig->sig_class);
1944         else if( !c->have_data ) {
1945             /* detached signature */
1946             free_md_filter_context( &c->mfx );
1947             c->mfx.md = md_open(sig->digest_algo, 0);
1948             if( !opt.pgp2_workarounds )
1949                 ;
1950             else if( sig->digest_algo == DIGEST_ALGO_MD5
1951                      && is_RSA( sig->pubkey_algo ) ) {
1952                 /* enable a workaround for a pgp2 bug */
1953                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1954             }
1955             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1956                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1957                      && sig->sig_class == 0x01 ) {
1958                 /* enable the workaround also for pgp5 when the detached
1959                  * signature has been created in textmode */
1960                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1961             }
1962 #if 0 /* workaround disabled */
1963             /* Here we have another hack to work around a pgp 2 bug
1964              * It works by not using the textmode for detached signatures;
1965              * this will let the first signature check (on md) fail
1966              * but the second one (on md2) which adds an extra CR should
1967              * then produce the "correct" hash.  This is very, very ugly
1968              * hack but it may help in some cases (and break others)
1969              */
1970                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
1971 #endif
1972             if ( DBG_HASHING ) {
1973                 md_start_debug( c->mfx.md, "verify" );
1974                 if ( c->mfx.md2  )
1975                     md_start_debug( c->mfx.md2, "verify2" );
1976             }
1977             if( c->sigs_only ) {
1978                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1979                                      c->signed_data, c->sigfilename,
1980                                      (sig->sig_class == 0x01) );
1981             }
1982             else {
1983                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1984                                                 iobuf_get_real_fname(c->iobuf),
1985                                                 (sig->sig_class == 0x01) );
1986             }
1987             if( rc ) {
1988                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1989                 return;
1990             }
1991         }
1992         else if ( c->signed_data ) {
1993             log_error (_("not a detached signature\n") );
1994             return;
1995         }
1996         else if ( c->pipemode.op == 'B' )
1997             ; /* this is a detached signature trough the pipemode handler */
1998         else if (!opt.quiet)
1999             log_info(_("old style (PGP 2.x) signature\n"));
2000
2001         if(multiple_ok)
2002           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2003             check_sig_and_print( c, n1 );
2004         else
2005           check_sig_and_print( c, node );
2006     }
2007     else {
2008         dump_kbnode (c->list);
2009         log_error(_("invalid root packet detected in proc_tree()\n"));
2010         dump_kbnode (node);
2011     }
2012 }