Implemented PKA trust model
[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 (has_invalid_email_chars (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       {
1507         const char *uri = pka_uri_from_sig (sig);
1508         
1509         if (uri)
1510           {
1511             int res;
1512             struct keyserver_spec *spec;
1513             
1514             spec = parse_keyserver_uri (uri, 0, NULL, 0);
1515             if (spec)
1516               {
1517                 glo_ctrl.in_auto_key_retrieve++;
1518                 res = keyserver_import_keyid (sig->keyid, spec);
1519                 glo_ctrl.in_auto_key_retrieve--;
1520                 free_keyserver_spec (spec);
1521                 if (!res)
1522                   rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1523               }
1524           }
1525       }
1526
1527
1528     /* If the preferred keyserver thing above didn't work and we got
1529        no information from the DNS PKA, this is a third try. */
1530
1531     if( rc == G10ERR_NO_PUBKEY && opt.keyserver
1532         && (opt.keyserver_options.options&KEYSERVER_AUTO_KEY_RETRIEVE))
1533       {
1534         int res;
1535
1536         glo_ctrl.in_auto_key_retrieve++;
1537         res=keyserver_import_keyid ( sig->keyid, opt.keyserver );
1538         glo_ctrl.in_auto_key_retrieve--;
1539         if(!res)
1540           rc = do_check_sig(c, node, NULL, &is_expkey, &is_revkey );
1541       }
1542
1543     if( !rc || rc == G10ERR_BAD_SIGN ) {
1544         KBNODE un, keyblock;
1545         int count=0, statno;
1546         char keyid_str[50];
1547         PKT_public_key *pk=NULL;
1548
1549         if(rc)
1550           statno=STATUS_BADSIG;
1551         else if(sig->flags.expired)
1552           statno=STATUS_EXPSIG;
1553         else if(is_expkey)
1554           statno=STATUS_EXPKEYSIG;
1555         else if(is_revkey)
1556           statno=STATUS_REVKEYSIG;
1557         else
1558           statno=STATUS_GOODSIG;
1559
1560         keyblock = get_pubkeyblock( sig->keyid );
1561
1562         sprintf (keyid_str, "%08lX%08lX [uncertain] ",
1563                  (ulong)sig->keyid[0], (ulong)sig->keyid[1]);
1564
1565         /* find and print the primary user ID */
1566         for( un=keyblock; un; un = un->next ) {
1567             char *p;
1568             int valid;
1569             if(un->pkt->pkttype==PKT_PUBLIC_KEY)
1570               {
1571                 pk=un->pkt->pkt.public_key;
1572                 continue;
1573               }
1574             if( un->pkt->pkttype != PKT_USER_ID )
1575                 continue;
1576             if ( !un->pkt->pkt.user_id->created )
1577                 continue;
1578             if ( un->pkt->pkt.user_id->is_revoked )
1579                 continue;
1580             if ( un->pkt->pkt.user_id->is_expired )
1581                 continue;
1582             if ( !un->pkt->pkt.user_id->is_primary )
1583                 continue;
1584             /* We want the textual primary user ID here */
1585             if ( un->pkt->pkt.user_id->attrib_data )
1586                 continue;
1587
1588             assert(pk);
1589
1590             /* Get it before we print anything to avoid interrupting
1591                the output with the "please do a --check-trustdb"
1592                line. */
1593             valid=get_validity(pk,un->pkt->pkt.user_id);
1594
1595             keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1596             write_status_text_and_buffer (statno, keyid_str,
1597                                           un->pkt->pkt.user_id->name,
1598                                           un->pkt->pkt.user_id->len, 
1599                                           -1 );
1600
1601             p=utf8_to_native(un->pkt->pkt.user_id->name,
1602                              un->pkt->pkt.user_id->len,0);
1603
1604             if(rc)
1605               log_info(_("BAD signature from \"%s\""),p);
1606             else if(sig->flags.expired)
1607               log_info(_("Expired signature from \"%s\""),p);
1608             else
1609               log_info(_("Good signature from \"%s\""),p);
1610
1611             xfree(p);
1612
1613             if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1614               fprintf(log_stream()," [%s]\n",trust_value_to_string(valid));
1615             else
1616               fputs("\n", log_stream() );
1617             count++;
1618         }
1619         if( !count ) {  /* just in case that we have no valid textual
1620                            userid */
1621             char *p;
1622
1623             /* Try for an invalid textual userid */
1624             for( un=keyblock; un; un = un->next ) {
1625                 if( un->pkt->pkttype == PKT_USER_ID &&
1626                     !un->pkt->pkt.user_id->attrib_data )
1627                     break;
1628             }
1629
1630             /* Try for any userid at all */
1631             if(!un) {
1632                 for( un=keyblock; un; un = un->next ) {
1633                     if( un->pkt->pkttype == PKT_USER_ID )
1634                         break;
1635                 }
1636             }
1637
1638             if (opt.trust_model==TM_ALWAYS || !un)
1639                 keyid_str[17] = 0; /* cut off the "[uncertain]" part */
1640
1641             write_status_text_and_buffer (statno, keyid_str,
1642                                           un? un->pkt->pkt.user_id->name:"[?]",
1643                                           un? un->pkt->pkt.user_id->len:3, 
1644                                           -1 );
1645
1646             if(un)
1647               p=utf8_to_native(un->pkt->pkt.user_id->name,
1648                                un->pkt->pkt.user_id->len,0);
1649             else
1650               p=xstrdup("[?]");
1651
1652             if(rc)
1653               log_info(_("BAD signature from \"%s\""),p);
1654             else if(sig->flags.expired)
1655               log_info(_("Expired signature from \"%s\""),p);
1656             else
1657               log_info(_("Good signature from \"%s\""),p);
1658             if (opt.trust_model!=TM_ALWAYS && un)
1659               {
1660                 putc(' ', log_stream() );
1661                 fputs(_("[uncertain]"), log_stream() );
1662               }
1663             fputs("\n", log_stream() );
1664         }
1665
1666         /* If we have a good signature and already printed 
1667          * the primary user ID, print all the other user IDs */
1668         if ( count && !rc ) {
1669             char *p;
1670             for( un=keyblock; un; un = un->next ) {
1671                 if( un->pkt->pkttype != PKT_USER_ID )
1672                     continue;
1673                 if((un->pkt->pkt.user_id->is_revoked
1674                     || un->pkt->pkt.user_id->is_expired)
1675                    && !(opt.verify_options&VERIFY_SHOW_UNUSABLE_UIDS))
1676                   continue;
1677                 /* Only skip textual primaries */
1678                 if ( un->pkt->pkt.user_id->is_primary &&
1679                      !un->pkt->pkt.user_id->attrib_data )
1680                     continue;
1681
1682                 if(un->pkt->pkt.user_id->attrib_data)
1683                   {
1684                     dump_attribs(un->pkt->pkt.user_id,pk,NULL);
1685
1686                     if(opt.verify_options&VERIFY_SHOW_PHOTOS)
1687                       show_photos(un->pkt->pkt.user_id->attribs,
1688                                   un->pkt->pkt.user_id->numattribs,pk,NULL);
1689                   }
1690
1691                 p=utf8_to_native(un->pkt->pkt.user_id->name,
1692                                  un->pkt->pkt.user_id->len,0);
1693                 log_info(_("                aka \"%s\""),p);
1694                 xfree(p);
1695
1696                 if(opt.verify_options&VERIFY_SHOW_UID_VALIDITY)
1697                   {
1698                     const char *valid;
1699                     if(un->pkt->pkt.user_id->is_revoked)
1700                       valid=_("revoked");
1701                     else if(un->pkt->pkt.user_id->is_expired)
1702                       valid=_("expired");
1703                     else
1704                       valid=trust_value_to_string(get_validity(pk,
1705                                                                un->pkt->
1706                                                                pkt.user_id));
1707                     fprintf(log_stream()," [%s]\n",valid);
1708                   }
1709                 else
1710                   fputs("\n", log_stream() );
1711             }
1712         }
1713         release_kbnode( keyblock );
1714
1715         if( !rc )
1716           {
1717             if(opt.verify_options&VERIFY_SHOW_POLICY_URLS)
1718               show_policy_url(sig,0,1);
1719             else
1720               show_policy_url(sig,0,2);
1721
1722             if(opt.verify_options&VERIFY_SHOW_KEYSERVER_URLS)
1723               show_keyserver_url(sig,0,1);
1724             else
1725               show_keyserver_url(sig,0,2);
1726
1727             if(opt.verify_options&VERIFY_SHOW_NOTATIONS)
1728               show_notation(sig,0,1,
1729                         ((opt.verify_options&VERIFY_SHOW_STD_NOTATIONS)?1:0)+
1730                         ((opt.verify_options&VERIFY_SHOW_USER_NOTATIONS)?2:0));
1731             else
1732               show_notation(sig,0,2,0);
1733           }
1734
1735         if( !rc && is_status_enabled() ) {
1736             /* print a status response with the fingerprint */
1737             PKT_public_key *vpk = xmalloc_clear( sizeof *vpk );
1738
1739             if( !get_pubkey( vpk, sig->keyid ) ) {
1740                 byte array[MAX_FINGERPRINT_LEN], *p;
1741                 char buf[MAX_FINGERPRINT_LEN*4+90], *bufp;
1742                 size_t i, n;
1743
1744                 bufp = buf;
1745                 fingerprint_from_pk( vpk, array, &n );
1746                 p = array;
1747                 for(i=0; i < n ; i++, p++, bufp += 2)
1748                     sprintf(bufp, "%02X", *p );
1749                 /* TODO: Replace the reserved '0' in the field below
1750                    with bits for status flags (policy url, notation,
1751                    etc.).  Remember to make the buffer larger to
1752                    match! */
1753                 sprintf(bufp, " %s %lu %lu %d 0 %d %d %02X ",
1754                         strtimestamp( sig->timestamp ),
1755                         (ulong)sig->timestamp,(ulong)sig->expiredate,
1756                         sig->version,sig->pubkey_algo,sig->digest_algo,
1757                         sig->sig_class);
1758                 bufp = bufp + strlen (bufp);
1759                 if (!vpk->is_primary) {
1760                    u32 akid[2];
1761  
1762                    akid[0] = vpk->main_keyid[0];
1763                    akid[1] = vpk->main_keyid[1];
1764                    free_public_key (vpk);
1765                    vpk = xmalloc_clear( sizeof *vpk );
1766                    if (get_pubkey (vpk, akid)) {
1767                      /* impossible error, we simply return a zeroed out fpr */
1768                      n = MAX_FINGERPRINT_LEN < 20? MAX_FINGERPRINT_LEN : 20;
1769                      memset (array, 0, n);
1770                    }
1771                    else
1772                      fingerprint_from_pk( vpk, array, &n );
1773                 }
1774                 p = array;
1775                 for(i=0; i < n ; i++, p++, bufp += 2)
1776                     sprintf(bufp, "%02X", *p );
1777                 write_status_text( STATUS_VALIDSIG, buf );
1778             }
1779             free_public_key( vpk );
1780         }
1781
1782         if (!rc)
1783           {
1784             pka_uri_from_sig (sig); /* Make sure PKA info is available. */
1785             rc = check_signatures_trust( sig );
1786           }
1787
1788         if(sig->flags.expired)
1789           {
1790             log_info(_("Signature expired %s\n"),
1791                      asctimestamp(sig->expiredate));
1792             rc=G10ERR_GENERAL; /* need a better error here? */
1793           }
1794         else if(sig->expiredate)
1795           log_info(_("Signature expires %s\n"),asctimestamp(sig->expiredate));
1796
1797         if(opt.verbose)
1798           log_info(_("%s signature, digest algorithm %s\n"),
1799                    sig->sig_class==0x00?_("binary"):
1800                    sig->sig_class==0x01?_("textmode"):_("unknown"),
1801                    digest_algo_to_string(sig->digest_algo));
1802
1803         if( rc )
1804             g10_errors_seen = 1;
1805         if( opt.batch && rc )
1806             g10_exit(1);
1807     }
1808     else {
1809         char buf[50];
1810         sprintf(buf, "%08lX%08lX %d %d %02x %lu %d",
1811                      (ulong)sig->keyid[0], (ulong)sig->keyid[1],
1812                      sig->pubkey_algo, sig->digest_algo,
1813                      sig->sig_class, (ulong)sig->timestamp, rc );
1814         write_status_text( STATUS_ERRSIG, buf );
1815         if( rc == G10ERR_NO_PUBKEY ) {
1816             buf[16] = 0;
1817             write_status_text( STATUS_NO_PUBKEY, buf );
1818         }
1819         if( rc != G10ERR_NOT_PROCESSED )
1820             log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
1821     }
1822     return rc;
1823 }
1824
1825
1826 /****************
1827  * Process the tree which starts at node
1828  */
1829 static void
1830 proc_tree( CTX c, KBNODE node )
1831 {
1832     KBNODE n1;
1833     int rc;
1834
1835     if( opt.list_packets || opt.list_only )
1836         return;
1837
1838     /* we must skip our special plaintext marker packets here becuase
1839        they may be the root packet.  These packets are only used in
1840        addionla checks and skipping them here doesn't matter */
1841     while ( node
1842             && node->pkt->pkttype == PKT_GPG_CONTROL
1843             && node->pkt->pkt.gpg_control->control
1844                          == CTRLPKT_PLAINTEXT_MARK ) {
1845         node = node->next;
1846     }
1847     if (!node)
1848         return;
1849
1850     c->trustletter = ' ';
1851     if( node->pkt->pkttype == PKT_PUBLIC_KEY
1852         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1853         merge_keys_and_selfsig( node );
1854         list_node( c, node );
1855     }
1856     else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
1857         merge_keys_and_selfsig( node );
1858         list_node( c, node );
1859     }
1860     else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
1861         /* check all signatures */
1862         if( !c->have_data ) {
1863             free_md_filter_context( &c->mfx );
1864             /* prepare to create all requested message digests */
1865             c->mfx.md = md_open(0, 0);
1866
1867             /* fixme: why looking for the signature packet and not 1passpacket*/
1868             for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
1869                 md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
1870             }
1871             /* ask for file and hash it */
1872             if( c->sigs_only ) {
1873                 rc = hash_datafiles( c->mfx.md, NULL,
1874                                      c->signed_data, c->sigfilename,
1875                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1876             }
1877             else {
1878                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1879                                                 iobuf_get_real_fname(c->iobuf),
1880                         n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
1881             }
1882             if( rc ) {
1883                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1884                 return;
1885             }
1886         }
1887         else if ( c->signed_data ) {
1888             log_error (_("not a detached signature\n") );
1889             return;
1890         }
1891
1892         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1893             check_sig_and_print( c, n1 );
1894     }
1895     else if( node->pkt->pkttype == PKT_GPG_CONTROL
1896              && node->pkt->pkt.gpg_control->control
1897                 == CTRLPKT_CLEARSIGN_START ) {
1898         /* clear text signed message */
1899         if( !c->have_data ) {
1900             log_error("cleartext signature without data\n" );
1901             return;
1902         }
1903         else if ( c->signed_data ) {
1904             log_error (_("not a detached signature\n") );
1905             return;
1906         }
1907         
1908         for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
1909             check_sig_and_print( c, n1 );
1910     }
1911     else if( node->pkt->pkttype == PKT_SIGNATURE ) {
1912         PKT_signature *sig = node->pkt->pkt.signature;
1913         int multiple_ok=1;
1914
1915         n1=find_next_kbnode(node, PKT_SIGNATURE);
1916         if(n1)
1917           {
1918             byte class=sig->sig_class;
1919             byte hash=sig->digest_algo;
1920
1921             for(; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE)))
1922               {
1923                 /* We can't currently handle multiple signatures of
1924                    different classes or digests (we'd pretty much have
1925                    to run a different hash context for each), but if
1926                    they are all the same, make an exception. */
1927                 if(n1->pkt->pkt.signature->sig_class!=class
1928                    || n1->pkt->pkt.signature->digest_algo!=hash)
1929                   {
1930                     multiple_ok=0;
1931                     log_info(_("WARNING: multiple signatures detected.  "
1932                                "Only the first will be checked.\n"));
1933                     break;
1934                   }
1935               }
1936           }
1937
1938         if( sig->sig_class != 0x00 && sig->sig_class != 0x01 )
1939             log_info(_("standalone signature of class 0x%02x\n"),
1940                                                     sig->sig_class);
1941         else if( !c->have_data ) {
1942             /* detached signature */
1943             free_md_filter_context( &c->mfx );
1944             c->mfx.md = md_open(sig->digest_algo, 0);
1945             if( !opt.pgp2_workarounds )
1946                 ;
1947             else if( sig->digest_algo == DIGEST_ALGO_MD5
1948                      && is_RSA( sig->pubkey_algo ) ) {
1949                 /* enable a workaround for a pgp2 bug */
1950                 c->mfx.md2 = md_open( DIGEST_ALGO_MD5, 0 );
1951             }
1952             else if( sig->digest_algo == DIGEST_ALGO_SHA1
1953                      && sig->pubkey_algo == PUBKEY_ALGO_DSA
1954                      && sig->sig_class == 0x01 ) {
1955                 /* enable the workaround also for pgp5 when the detached
1956                  * signature has been created in textmode */
1957                 c->mfx.md2 = md_open( sig->digest_algo, 0 );
1958             }
1959 #if 0 /* workaround disabled */
1960             /* Here we have another hack to work around a pgp 2 bug
1961              * It works by not using the textmode for detached signatures;
1962              * this will let the first signature check (on md) fail
1963              * but the second one (on md2) which adds an extra CR should
1964              * then produce the "correct" hash.  This is very, very ugly
1965              * hack but it may help in some cases (and break others)
1966              */
1967                     /*  c->mfx.md2? 0 :(sig->sig_class == 0x01) */
1968 #endif
1969             if ( DBG_HASHING ) {
1970                 md_start_debug( c->mfx.md, "verify" );
1971                 if ( c->mfx.md2  )
1972                     md_start_debug( c->mfx.md2, "verify2" );
1973             }
1974             if( c->sigs_only ) {
1975                 rc = hash_datafiles( c->mfx.md, c->mfx.md2,
1976                                      c->signed_data, c->sigfilename,
1977                                      (sig->sig_class == 0x01) );
1978             }
1979             else {
1980                 rc = ask_for_detached_datafile( c->mfx.md, c->mfx.md2,
1981                                                 iobuf_get_real_fname(c->iobuf),
1982                                                 (sig->sig_class == 0x01) );
1983             }
1984             if( rc ) {
1985                 log_error("can't hash datafile: %s\n", g10_errstr(rc));
1986                 return;
1987             }
1988         }
1989         else if ( c->signed_data ) {
1990             log_error (_("not a detached signature\n") );
1991             return;
1992         }
1993         else if ( c->pipemode.op == 'B' )
1994             ; /* this is a detached signature trough the pipemode handler */
1995         else if (!opt.quiet)
1996             log_info(_("old style (PGP 2.x) signature\n"));
1997
1998         if(multiple_ok)
1999           for( n1 = node; n1; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )) )
2000             check_sig_and_print( c, n1 );
2001         else
2002           check_sig_and_print( c, node );
2003     }
2004     else {
2005         dump_kbnode (c->list);
2006         log_error(_("invalid root packet detected in proc_tree()\n"));
2007         dump_kbnode (node);
2008     }
2009 }