Added SELInux hacks and did some cleanups.
[gnupg.git] / g10 / import.c
1 /* import.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
3  *               2004 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <assert.h>
28
29 #include "options.h"
30 #include "packet.h"
31 #include "errors.h"
32 #include "keydb.h"
33 #include "memory.h"
34 #include "util.h"
35 #include "trustdb.h"
36 #include "main.h"
37 #include "i18n.h"
38 #include "ttyio.h"
39 #include "status.h"
40 #include "keyserver-internal.h"
41
42 struct stats_s {
43     ulong count;
44     ulong no_user_id;
45     ulong imported;
46     ulong imported_rsa;
47     ulong n_uids;
48     ulong n_sigs;
49     ulong n_subk;
50     ulong unchanged;
51     ulong n_revoc;
52     ulong secret_read;
53     ulong secret_imported;
54     ulong secret_dups;
55     ulong skipped_new_keys;
56     ulong not_imported;
57 };
58
59
60 static int import( IOBUF inp, const char* fname,
61                    struct stats_s *stats, unsigned int options );
62 static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
63 static void revocation_present(KBNODE keyblock);
64 static int import_one( const char *fname, KBNODE keyblock,
65                        struct stats_s *stats, unsigned int options);
66 static int import_secret_one( const char *fname, KBNODE keyblock,
67                               struct stats_s *stats, unsigned int options);
68 static int import_revoke_cert( const char *fname, KBNODE node,
69                                struct stats_s *stats);
70 static int chk_self_sigs( const char *fname, KBNODE keyblock,
71                           PKT_public_key *pk, u32 *keyid, int *non_self );
72 static int delete_inv_parts( const char *fname, KBNODE keyblock,
73                              u32 *keyid, unsigned int options );
74 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
75                          KBNODE keyblock, u32 *keyid,
76                          int *n_uids, int *n_sigs, int *n_subk );
77 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
78                              const char *fname, u32 *keyid );
79 static int append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
80                              const char *fname, u32 *keyid );
81 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
82                              const char *fname, u32 *keyid );
83 static int merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
84                              const char *fname, u32 *keyid );
85
86 int
87 parse_import_options(char *str,unsigned int *options,int noisy)
88 {
89   struct parse_options import_opts[]=
90     {
91       {"allow-local-sigs",IMPORT_ALLOW_LOCAL_SIGS,NULL},
92       {"repair-hkp-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
93       {"repair-pks-subkey-bug",IMPORT_REPAIR_PKS_SUBKEY_BUG,NULL},
94       {"fast-import",IMPORT_FAST_IMPORT,NULL},
95       {"convert-sk-to-pk",IMPORT_SK2PK,NULL},
96       {"merge-only",IMPORT_MERGE_ONLY,NULL},
97       {NULL,0,NULL}
98     };
99
100   return parse_options(str,options,import_opts,noisy);
101 }
102
103 void *
104 import_new_stats_handle (void)
105 {
106     return m_alloc_clear ( sizeof (struct stats_s) );
107 }
108
109 void
110 import_release_stats_handle (void *p)
111 {
112     m_free (p);
113 }
114
115 /****************
116  * Import the public keys from the given filename. Input may be armored.
117  * This function rejects all keys which are not validly self signed on at
118  * least one userid. Only user ids which are self signed will be imported.
119  * Other signatures are not checked.
120  *
121  * Actually this function does a merge. It works like this:
122  *
123  *  - get the keyblock
124  *  - check self-signatures and remove all userids and their signatures
125  *    without/invalid self-signatures.
126  *  - reject the keyblock, if we have no valid userid.
127  *  - See whether we have this key already in one of our pubrings.
128  *    If not, simply add it to the default keyring.
129  *  - Compare the key and the self-signatures of the new and the one in
130  *    our keyring.  If they are different something weird is going on;
131  *    ask what to do.
132  *  - See whether we have only non-self-signature on one user id; if not
133  *    ask the user what to do.
134  *  - compare the signatures: If we already have this signature, check
135  *    that they compare okay; if not, issue a warning and ask the user.
136  *    (consider looking at the timestamp and use the newest?)
137  *  - Simply add the signature.  Can't verify here because we may not have
138  *    the signature's public key yet; verification is done when putting it
139  *    into the trustdb, which is done automagically as soon as this pubkey
140  *    is used.
141  *  - Proceed with next signature.
142  *
143  *  Key revocation certificates have special handling.
144  *
145  */
146 static int
147 import_keys_internal( IOBUF inp, char **fnames, int nnames,
148                       void *stats_handle, unsigned int options )
149 {
150     int i, rc = 0;
151     struct stats_s *stats = stats_handle;
152
153     if (!stats)
154         stats = import_new_stats_handle ();
155
156     if (inp) {
157         rc = import( inp, "[stream]", stats, options);
158     }
159     else {
160         if( !fnames && !nnames )
161             nnames = 1;  /* Ohh what a ugly hack to jump into the loop */
162
163         for(i=0; i < nnames; i++ ) {
164             const char *fname = fnames? fnames[i] : NULL;
165             IOBUF inp2 = iobuf_open(fname);
166             if( !fname )
167                 fname = "[stdin]";
168             if (inp2 && is_secured_file (iobuf_get_fd (inp2)))
169               {
170                 iobuf_close (inp2);
171                 inp2 = NULL;
172                 errno = EPERM;
173               }
174             if( !inp2 )
175                 log_error(_("can't open `%s': %s\n"), fname, strerror(errno) );
176             else {
177                 rc = import( inp2, fname, stats, options );
178                 iobuf_close(inp2);
179                 /* Must invalidate that ugly cache to actually close it. */
180                 iobuf_ioctl (NULL, 2, 0, (char*)fname);
181                 if( rc )
182                     log_error("import from `%s' failed: %s\n", fname,
183                               g10_errstr(rc) );
184             }
185             if( !fname )
186                 break;
187         }
188     }
189     if (!stats_handle) {
190         import_print_stats (stats);
191         import_release_stats_handle (stats);
192     }
193     /* If no fast import and the trustdb is dirty (i.e. we added a key
194        or userID that had something other than a selfsig, a signature
195        that was other than a selfsig, or any revocation), then
196        update/check the trustdb if the user specified by setting
197        interactive or by not setting no-auto-check-trustdb */
198     if (!(options&IMPORT_FAST_IMPORT) && trustdb_pending_check())
199       {
200         if (opt.interactive)
201           update_trustdb();
202         else if (!opt.no_auto_check_trustdb)
203           check_trustdb();
204       }
205
206     return rc;
207 }
208
209 void
210 import_keys( char **fnames, int nnames,
211              void *stats_handle, unsigned int options )
212 {
213     import_keys_internal( NULL, fnames, nnames, stats_handle, options);
214 }
215
216 int
217 import_keys_stream( IOBUF inp, void *stats_handle, unsigned int options )
218 {
219     return import_keys_internal( inp, NULL, 0, stats_handle, options);
220 }
221
222 static int
223 import( IOBUF inp, const char* fname,
224         struct stats_s *stats, unsigned int options )
225 {
226     PACKET *pending_pkt = NULL;
227     KBNODE keyblock;
228     int rc = 0;
229
230     getkey_disable_caches();
231
232     if( !opt.no_armor ) { /* armored reading is not disabled */
233         armor_filter_context_t *afx = m_alloc_clear( sizeof *afx );
234         afx->only_keyblocks = 1;
235         iobuf_push_filter2( inp, armor_filter, afx, 1 );
236     }
237
238     while( !(rc = read_block( inp, &pending_pkt, &keyblock) )) {
239         if( keyblock->pkt->pkttype == PKT_PUBLIC_KEY )
240             rc = import_one( fname, keyblock, stats, options );
241         else if( keyblock->pkt->pkttype == PKT_SECRET_KEY ) 
242                 rc = import_secret_one( fname, keyblock, stats, options );
243         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
244                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
245             rc = import_revoke_cert( fname, keyblock, stats );
246         else {
247             log_info( _("skipping block of type %d\n"),
248                                             keyblock->pkt->pkttype );
249         }
250         release_kbnode(keyblock);
251         /* fixme: we should increment the not imported counter but this
252            does only make sense if we keep on going despite of errors. */
253         if( rc )
254             break;
255         if( !(++stats->count % 100) && !opt.quiet )
256             log_info(_("%lu keys processed so far\n"), stats->count );
257     }
258     if( rc == -1 )
259         rc = 0;
260     else if( rc && rc != G10ERR_INV_KEYRING )
261         log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
262
263     return rc;
264 }
265
266
267 void
268 import_print_stats (void *hd)
269 {
270     struct stats_s *stats = hd;
271
272     if( !opt.quiet ) {
273         log_info(_("Total number processed: %lu\n"), stats->count );
274         if( stats->skipped_new_keys )
275             log_info(_("      skipped new keys: %lu\n"),
276                                                 stats->skipped_new_keys );
277         if( stats->no_user_id )
278             log_info(_("          w/o user IDs: %lu\n"), stats->no_user_id );
279         if( stats->imported || stats->imported_rsa ) {
280             log_info(_("              imported: %lu"), stats->imported );
281             if( stats->imported_rsa )
282                 fprintf(stderr, "  (RSA: %lu)", stats->imported_rsa );
283             putc('\n', stderr);
284         }
285         if( stats->unchanged )
286             log_info(_("             unchanged: %lu\n"), stats->unchanged );
287         if( stats->n_uids )
288             log_info(_("          new user IDs: %lu\n"), stats->n_uids );
289         if( stats->n_subk )
290             log_info(_("           new subkeys: %lu\n"), stats->n_subk );
291         if( stats->n_sigs )
292             log_info(_("        new signatures: %lu\n"), stats->n_sigs );
293         if( stats->n_revoc )
294             log_info(_("   new key revocations: %lu\n"), stats->n_revoc );
295         if( stats->secret_read )
296             log_info(_("      secret keys read: %lu\n"), stats->secret_read );
297         if( stats->secret_imported )
298             log_info(_("  secret keys imported: %lu\n"), stats->secret_imported );
299         if( stats->secret_dups )
300             log_info(_(" secret keys unchanged: %lu\n"), stats->secret_dups );
301         if( stats->not_imported )
302             log_info(_("          not imported: %lu\n"), stats->not_imported );
303     }
304
305     if( is_status_enabled() ) {
306         char buf[14*20];
307         sprintf(buf, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
308                 stats->count,
309                 stats->no_user_id,
310                 stats->imported,
311                 stats->imported_rsa,
312                 stats->unchanged,
313                 stats->n_uids,
314                 stats->n_subk,
315                 stats->n_sigs,
316                 stats->n_revoc,
317                 stats->secret_read,
318                 stats->secret_imported,
319                 stats->secret_dups,
320                 stats->skipped_new_keys,
321                 stats->not_imported );
322         write_status_text( STATUS_IMPORT_RES, buf );
323     }
324 }
325
326
327 /****************
328  * Read the next keyblock from stream A.
329  * PENDING_PKT should be initialzed to NULL
330  * and not chnaged form the caller.
331  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
332  */
333 static int
334 read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
335 {
336     int rc;
337     PACKET *pkt;
338     KBNODE root = NULL;
339     int in_cert;
340
341     if( *pending_pkt ) {
342         root = new_kbnode( *pending_pkt );
343         *pending_pkt = NULL;
344         in_cert = 1;
345     }
346     else
347         in_cert = 0;
348     pkt = m_alloc( sizeof *pkt );
349     init_packet(pkt);
350     while( (rc=parse_packet(a, pkt)) != -1 ) {
351         if( rc ) {  /* ignore errors */
352             if( rc != G10ERR_UNKNOWN_PACKET ) {
353                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
354                 rc = G10ERR_INV_KEYRING;
355                 goto ready;
356             }
357             free_packet( pkt );
358             init_packet(pkt);
359             continue;
360         }
361
362         if( !root && pkt->pkttype == PKT_SIGNATURE
363                   && pkt->pkt.signature->sig_class == 0x20 ) {
364             /* this is a revocation certificate which is handled
365              * in a special way */
366             root = new_kbnode( pkt );
367             pkt = NULL;
368             goto ready;
369         }
370
371         /* make a linked list of all packets */
372         switch( pkt->pkttype ) {
373           case PKT_COMPRESSED:
374             if(check_compress_algo(pkt->pkt.compressed->algorithm))
375               {
376                 rc = G10ERR_COMPR_ALGO;
377                 goto ready;
378               }
379             else
380               {
381                 compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
382                 pkt->pkt.compressed->buf = NULL;
383                 push_compress_filter2(a,cfx,pkt->pkt.compressed->algorithm,1);
384               }
385             free_packet( pkt );
386             init_packet(pkt);
387             break;
388
389           case PKT_RING_TRUST:
390             /* skip those packets */
391             free_packet( pkt );
392             init_packet(pkt);
393             break;
394
395           case PKT_PUBLIC_KEY:
396           case PKT_SECRET_KEY:
397             if( in_cert ) { /* store this packet */
398                 *pending_pkt = pkt;
399                 pkt = NULL;
400                 goto ready;
401             }
402             in_cert = 1;
403           default:
404             if( in_cert ) {
405                 if( !root )
406                     root = new_kbnode( pkt );
407                 else
408                     add_kbnode( root, new_kbnode( pkt ) );
409                 pkt = m_alloc( sizeof *pkt );
410             }
411             init_packet(pkt);
412             break;
413         }
414     }
415   ready:
416     if( rc == -1 && root )
417         rc = 0;
418
419     if( rc )
420         release_kbnode( root );
421     else
422         *ret_root = root;
423     free_packet( pkt );
424     m_free( pkt );
425     return rc;
426 }
427
428 /* Walk through the subkeys on a pk to find if we have the PKS
429    disease: multiple subkeys with their binding sigs stripped, and the
430    sig for the first subkey placed after the last subkey.  That is,
431    instead of "pk uid sig sub1 bind1 sub2 bind2 sub3 bind3" we have
432    "pk uid sig sub1 sub2 sub3 bind1".  We can't do anything about sub2
433    and sub3, as they are already lost, but we can try and rescue sub1
434    by reordering the keyblock so that it reads "pk uid sig sub1 bind1
435    sub2 sub3".  Returns TRUE if the keyblock was modified. */
436
437 static int
438 fix_pks_corruption(KBNODE keyblock)
439 {
440   int changed=0,keycount=0;
441   KBNODE node,last=NULL,sknode=NULL;
442
443   /* First determine if we have the problem at all.  Look for 2 or
444      more subkeys in a row, followed by a single binding sig. */
445   for(node=keyblock;node;last=node,node=node->next)
446     {
447       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
448         {
449           keycount++;
450           if(!sknode)
451             sknode=node;
452         }
453       else if(node->pkt->pkttype==PKT_SIGNATURE &&
454               node->pkt->pkt.signature->sig_class==0x18 &&
455               keycount>=2 && node->next==NULL)
456         {
457           /* We might have the problem, as this key has two subkeys in
458              a row without any intervening packets. */
459
460           /* Sanity check */
461           if(last==NULL)
462             break;
463
464           /* Temporarily attach node to sknode. */
465           node->next=sknode->next;
466           sknode->next=node;
467           last->next=NULL;
468
469           /* Note we aren't checking whether this binding sig is a
470              selfsig.  This is not necessary here as the subkey and
471              binding sig will be rejected later if that is the
472              case. */
473           if(check_key_signature(keyblock,node,NULL))
474             {
475               /* Not a match, so undo the changes. */
476               sknode->next=node->next;
477               last->next=node;
478               node->next=NULL;
479               break;
480             }
481           else
482             {
483               sknode->flag |= 1; /* Mark it good so we don't need to
484                                     check it again */
485               changed=1;
486               break;
487             }
488         }
489       else
490         keycount=0;
491     }
492
493   return changed;
494 }
495
496
497 static void
498 print_import_ok (PKT_public_key *pk, PKT_secret_key *sk, unsigned int reason)
499 {
500   byte array[MAX_FINGERPRINT_LEN], *s;
501   char buf[MAX_FINGERPRINT_LEN*2+30], *p;
502   size_t i, n;
503
504   sprintf (buf, "%u ", reason);
505   p = buf + strlen (buf);
506
507   if (pk)
508     fingerprint_from_pk (pk, array, &n);
509   else
510     fingerprint_from_sk (sk, array, &n);
511   s = array;
512   for (i=0; i < n ; i++, s++, p += 2)
513     sprintf (p, "%02X", *s);
514
515   write_status_text (STATUS_IMPORT_OK, buf);
516 }
517
518 static void
519 print_import_check (PKT_public_key * pk, PKT_user_id * id)
520 {
521     char * buf;
522     byte fpr[24];
523     u32 keyid[2];
524     size_t i, pos = 0, n;
525
526     buf = m_alloc (17+41+id->len+32);
527     keyid_from_pk (pk, keyid);
528     sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
529     pos = 17;
530     fingerprint_from_pk (pk, fpr, &n);
531     for (i = 0; i < n; i++, pos += 2)
532         sprintf (buf+pos, "%02X", fpr[i]);
533     strcat (buf, " ");
534     pos += 1;
535     strcat (buf, id->name);
536     write_status_text (STATUS_IMPORT_CHECK, buf);
537     m_free (buf);
538 }
539
540 static void
541 check_prefs_warning(PKT_public_key *pk)
542 {
543   log_info(_("WARNING: key %s contains preferences for unavailable\n"),
544            keystr_from_pk(pk));
545   log_info(_("algorithms on these user IDs:\n"));
546 }
547
548 static void
549 check_prefs(KBNODE keyblock)
550 {
551   KBNODE node;
552   PKT_public_key *pk;
553   int problem=0;
554   
555   merge_keys_and_selfsig(keyblock);
556   pk=keyblock->pkt->pkt.public_key;
557
558   for(node=keyblock;node;node=node->next)
559     {
560       if(node->pkt->pkttype==PKT_USER_ID
561          && node->pkt->pkt.user_id->created
562          && node->pkt->pkt.user_id->prefs)
563         {
564           PKT_user_id *uid=node->pkt->pkt.user_id;
565           prefitem_t *prefs=uid->prefs;
566           char *user=utf8_to_native(uid->name,strlen(uid->name),0);
567
568           for(;prefs->type;prefs++)
569             {
570               char num[10]; /* prefs->value is a byte, so we're over
571                                safe here */
572
573               sprintf(num,"%u",prefs->value);
574
575               if(prefs->type==PREFTYPE_SYM)
576                 {
577                   if(check_cipher_algo(prefs->value))
578                     {
579                       const char *algo=cipher_algo_to_string(prefs->value);
580                       if(!problem)
581                         check_prefs_warning(pk);
582                       log_info(_("         \"%s\": preference for cipher"
583                                  " algorithm %s\n"),user,algo?algo:num);
584                       problem=1;
585                     }
586                 }
587               else if(prefs->type==PREFTYPE_HASH)
588                 {
589                   if(check_digest_algo(prefs->value))
590                     {
591                       const char *algo=digest_algo_to_string(prefs->value);
592                       if(!problem)
593                         check_prefs_warning(pk);
594                       log_info(_("         \"%s\": preference for digest"
595                                  " algorithm %s\n"),user,algo?algo:num);
596                       problem=1;
597                     }
598                 }
599               else if(prefs->type==PREFTYPE_ZIP)
600                 {
601                   if(check_compress_algo(prefs->value))
602                     {
603                       const char *algo=compress_algo_to_string(prefs->value);
604                       if(!problem)
605                         check_prefs_warning(pk);
606                       log_info(_("         \"%s\": preference for compression"
607                                  " algorithm %s\n"),user,algo?algo:num);
608                       problem=1;
609                     }
610                 }
611             }
612
613           m_free(user);
614         }
615     }
616
617   if(problem)
618     {
619       log_info(_("it is strongly suggested that you update"
620                  " your preferences and\n"));
621       log_info(_("re-distribute this key to avoid potential algorithm"
622                  " mismatch problems\n"));
623
624       if(!opt.batch)
625         {
626           STRLIST sl=NULL,locusr=NULL;
627           size_t fprlen=0;
628           byte fpr[MAX_FINGERPRINT_LEN],*p;
629           char username[(MAX_FINGERPRINT_LEN*2)+1];
630           unsigned int i;
631
632           p=fingerprint_from_pk(pk,fpr,&fprlen);
633           for(i=0;i<fprlen;i++,p++)
634             sprintf(username+2*i,"%02X",*p);
635           add_to_strlist(&locusr,username);
636
637           append_to_strlist(&sl,"updpref");
638           append_to_strlist(&sl,"save");
639
640           keyedit_menu( username, locusr, sl, 1, 1 );
641           free_strlist(sl);
642           free_strlist(locusr);
643         }
644       else if(!opt.quiet)
645         log_info(_("you can update your preferences with:"
646                    " gpg --edit-key %s updpref save\n"),keystr_from_pk(pk));
647     }
648 }
649
650 /****************
651  * Try to import one keyblock.  Return an error only in serious cases, but
652  * never for an invalid keyblock.  It uses log_error to increase the
653  * internal errorcount, so that invalid input can be detected by programs
654  * which called g10.
655  */
656 static int
657 import_one( const char *fname, KBNODE keyblock,
658             struct stats_s *stats, unsigned int options )
659 {
660     PKT_public_key *pk;
661     PKT_public_key *pk_orig;
662     KBNODE node, uidnode;
663     KBNODE keyblock_orig = NULL;
664     u32 keyid[2];
665     int rc = 0;
666     int new_key = 0;
667     int mod_key = 0;
668     int non_self = 0;
669
670     /* get the key and print some info about it */
671     node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
672     if( !node )
673         BUG();
674
675     pk = node->pkt->pkt.public_key;
676     keyid_from_pk( pk, keyid );
677     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
678
679     if( opt.verbose && !opt.interactive )
680       {
681         log_info( "pub  %4u%c/%s %s  ",
682                   nbits_from_pk( pk ),
683                   pubkey_letter( pk->pubkey_algo ),
684                   keystr_from_pk(pk), datestr_from_pk(pk) );
685         if( uidnode )
686           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
687                              uidnode->pkt->pkt.user_id->len );
688         putc('\n', stderr);
689       }
690
691     if( !uidnode )
692       {
693         log_error( _("key %s: no user ID\n"), keystr_from_pk(pk));
694         return 0;
695       }
696     
697     if (opt.interactive) {
698         if(is_status_enabled())
699           print_import_check (pk, uidnode->pkt->pkt.user_id);
700         merge_keys_and_selfsig (keyblock);
701         tty_printf ("\n");
702         show_basic_key_info (keyblock);
703         tty_printf ("\n");
704         if (!cpr_get_answer_is_yes ("import.okay",
705                                     "Do you want to import this key? (y/N) "))
706             return 0;
707     }
708
709     clear_kbnode_flags( keyblock );
710
711     if((options&IMPORT_REPAIR_PKS_SUBKEY_BUG) && fix_pks_corruption(keyblock)
712        && opt.verbose)
713       log_info(_("key %s: PKS subkey corruption repaired\n"),
714                keystr_from_pk(pk));
715
716     rc = chk_self_sigs( fname, keyblock , pk, keyid, &non_self );
717     if( rc )
718         return rc== -1? 0:rc;
719
720     /* If we allow such a thing, mark unsigned uids as valid */
721     if( opt.allow_non_selfsigned_uid )
722       for( node=keyblock; node; node = node->next )
723         if( node->pkt->pkttype == PKT_USER_ID && !(node->flag & 1) )
724           {
725             char *user=utf8_to_native(node->pkt->pkt.user_id->name,
726                                       node->pkt->pkt.user_id->len,0);
727             node->flag |= 1;
728             log_info( _("key %s: accepted non self-signed user ID \"%s\"\n"),
729                       keystr_from_pk(pk),user);
730             m_free(user);
731           }
732
733     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
734         log_error( _("key %s: no valid user IDs\n"), keystr_from_pk(pk));
735         if( !opt.quiet )
736           log_info(_("this may be caused by a missing self-signature\n"));
737         stats->no_user_id++;
738         return 0;
739     }
740
741     /* do we have this key already in one of our pubrings ? */
742     pk_orig = m_alloc_clear( sizeof *pk_orig );
743     rc = get_pubkey_fast ( pk_orig, keyid );
744     if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY )
745       {
746         log_error( _("key %s: public key not found: %s\n"),
747                    keystr(keyid), g10_errstr(rc));
748       }
749     else if ( rc && (opt.import_options&IMPORT_MERGE_ONLY) )
750       {
751         if( opt.verbose )
752           log_info( _("key %s: new key - skipped\n"), keystr(keyid));
753         rc = 0;
754         stats->skipped_new_keys++;
755       }
756     else if( rc ) { /* insert this key */
757         KEYDB_HANDLE hd = keydb_new (0);
758
759         rc = keydb_locate_writable (hd, NULL);
760         if (rc) {
761             log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
762             keydb_release (hd);
763             return G10ERR_GENERAL;
764         }
765         if( opt.verbose > 1 )
766             log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
767
768         collapse_uids(&keyblock);
769
770         rc = keydb_insert_keyblock (hd, keyblock );
771         if (rc)
772            log_error (_("error writing keyring `%s': %s\n"),
773                        keydb_get_resource_name (hd), g10_errstr(rc));
774         else
775           {
776             /* This should not be possible since we delete the
777                ownertrust when a key is deleted, but it can happen if
778                the keyring and trustdb are out of sync.  It can also
779                be made to happen with the trusted-key command. */
780
781             clear_ownertrusts (pk);
782             if(non_self)
783               revalidation_mark ();
784           }
785         keydb_release (hd);
786
787         /* we are ready */
788         if( !opt.quiet )
789           {
790             char *p=get_user_id_native (keyid);
791             log_info( _("key %s: public key \"%s\" imported\n"),
792                       keystr(keyid),p);
793             m_free(p);
794           }
795         if( is_status_enabled() )
796           {
797             char *us = get_long_user_id_string( keyid );
798             write_status_text( STATUS_IMPORTED, us );
799             m_free(us);
800             print_import_ok (pk,NULL, 1);
801           }
802         stats->imported++;
803         if( is_RSA( pk->pubkey_algo ) )
804             stats->imported_rsa++;
805         new_key = 1;
806     }
807     else { /* merge */
808         KEYDB_HANDLE hd;
809         int n_uids, n_sigs, n_subk;
810
811         /* Compare the original against the new key; just to be sure nothing
812          * weird is going on */
813         if( cmp_public_keys( pk_orig, pk ) )
814           {
815             log_error( _("key %s: doesn't match our copy\n"),keystr(keyid));
816             goto leave;
817           }
818
819         /* now read the original keyblock */
820         hd = keydb_new (0);
821         {
822             byte afp[MAX_FINGERPRINT_LEN];
823             size_t an;
824
825             fingerprint_from_pk (pk_orig, afp, &an);
826             while (an < MAX_FINGERPRINT_LEN) 
827                 afp[an++] = 0;
828             rc = keydb_search_fpr (hd, afp);
829         }
830         if( rc )
831           {
832             log_error (_("key %s: can't locate original keyblock: %s\n"),
833                        keystr(keyid), g10_errstr(rc));
834             keydb_release (hd);
835             goto leave;
836           }
837         rc = keydb_get_keyblock (hd, &keyblock_orig );
838         if (rc)
839           {
840             log_error (_("key %s: can't read original keyblock: %s\n"),
841                        keystr(keyid), g10_errstr(rc));
842             keydb_release (hd);
843             goto leave;
844           }
845
846         collapse_uids( &keyblock );
847         /* and try to merge the block */
848         clear_kbnode_flags( keyblock_orig );
849         clear_kbnode_flags( keyblock );
850         n_uids = n_sigs = n_subk = 0;
851         rc = merge_blocks( fname, keyblock_orig, keyblock,
852                                 keyid, &n_uids, &n_sigs, &n_subk );
853         if( rc ) {
854             keydb_release (hd);
855             goto leave;
856         }
857         if( n_uids || n_sigs || n_subk ) {
858             mod_key = 1;
859             /* keyblock_orig has been updated; write */
860             rc = keydb_update_keyblock (hd, keyblock_orig);
861             if (rc)
862                 log_error (_("error writing keyring `%s': %s\n"),
863                              keydb_get_resource_name (hd), g10_errstr(rc) );
864             else if(non_self)
865               revalidation_mark ();
866
867             /* we are ready */
868             if( !opt.quiet )
869               {
870                 char *p=get_user_id_native(keyid);
871                 if( n_uids == 1 )
872                   log_info( _("key %s: \"%s\" 1 new user ID\n"),
873                            keystr(keyid),p);
874                 else if( n_uids )
875                   log_info( _("key %s: \"%s\" %d new user IDs\n"),
876                             keystr(keyid),p,n_uids);
877                 if( n_sigs == 1 )
878                   log_info( _("key %s: \"%s\" 1 new signature\n"),
879                             keystr(keyid), p);
880                 else if( n_sigs )
881                   log_info( _("key %s: \"%s\" %d new signatures\n"),
882                             keystr(keyid), p, n_sigs );
883                 if( n_subk == 1 )
884                   log_info( _("key %s: \"%s\" 1 new subkey\n"),
885                             keystr(keyid), p);
886                 else if( n_subk )
887                   log_info( _("key %s: \"%s\" %d new subkeys\n"),
888                             keystr(keyid), p, n_subk );
889                 m_free(p);
890               }
891
892             stats->n_uids +=n_uids;
893             stats->n_sigs +=n_sigs;
894             stats->n_subk +=n_subk;
895
896             if (is_status_enabled ()) 
897                  print_import_ok (pk, NULL,
898                                   ((n_uids?2:0)|(n_sigs?4:0)|(n_subk?8:0)));
899         }
900         else
901           {
902             if (is_status_enabled ()) 
903               print_import_ok (pk, NULL, 0);
904
905             if( !opt.quiet )
906               {
907                 char *p=get_user_id_native(keyid);
908                 log_info( _("key %s: \"%s\" not changed\n"),keystr(keyid),p);
909                 m_free(p);
910               }
911
912             stats->unchanged++;
913           }
914
915         keydb_release (hd); hd = NULL;
916     }
917
918   leave:
919
920     /* Now that the key is definitely incorporated into the keydb, we
921        need to check if a designated revocation is present or if the
922        prefs are not rational so we can warn the user. */
923
924     if(mod_key)
925       {
926         revocation_present(keyblock_orig);
927         if(seckey_available(keyid)==0)
928           check_prefs(keyblock_orig);
929       }
930     else if(new_key)
931       {
932         revocation_present(keyblock);
933         if(seckey_available(keyid)==0)
934           check_prefs(keyblock);
935       }
936
937     release_kbnode( keyblock_orig );
938     free_public_key( pk_orig );
939
940     return rc;
941 }
942
943 /* Walk a secret keyblock and produce a public keyblock out of it. */
944 static KBNODE
945 sec_to_pub_keyblock(KBNODE sec_keyblock)
946 {
947   KBNODE secnode,pub_keyblock=NULL,ctx=NULL;
948
949   while((secnode=walk_kbnode(sec_keyblock,&ctx,0)))
950     {
951       KBNODE pubnode;
952
953       if(secnode->pkt->pkttype==PKT_SECRET_KEY ||
954          secnode->pkt->pkttype==PKT_SECRET_SUBKEY)
955         {
956           /* Make a public key.  We only need to convert enough to
957              write the keyblock out. */
958
959           PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
960           PACKET *pkt=m_alloc_clear(sizeof(PACKET));
961           PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
962           int n;
963
964           if(secnode->pkt->pkttype==PKT_SECRET_KEY)
965             pkt->pkttype=PKT_PUBLIC_KEY;
966           else
967             pkt->pkttype=PKT_PUBLIC_SUBKEY;
968
969           pkt->pkt.public_key=pk;
970
971           pk->version=sk->version;
972           pk->timestamp=sk->timestamp;
973           pk->expiredate=sk->expiredate;
974           pk->pubkey_algo=sk->pubkey_algo;
975
976           n=pubkey_get_npkey(pk->pubkey_algo);
977           if(n==0)
978             {
979               /* we can't properly extract the pubkey without knowing
980                  the number of MPIs */
981               release_kbnode(pub_keyblock);
982               return NULL;
983             }
984           else
985             {
986               int i;
987
988               for(i=0;i<n;i++)
989                 pk->pkey[i]=mpi_copy(sk->skey[i]);
990             }
991
992           pubnode=new_kbnode(pkt);
993         }
994       else
995         {
996           pubnode=clone_kbnode(secnode);
997         }
998
999       if(pub_keyblock==NULL)
1000         pub_keyblock=pubnode;
1001       else
1002         add_kbnode(pub_keyblock,pubnode);
1003     }
1004
1005   return pub_keyblock;
1006 }
1007
1008 /****************
1009  * Ditto for secret keys.  Handling is simpler than for public keys.
1010  * We allow secret key importing only when allow is true, this is so
1011  * that a secret key can not be imported accidently and thereby tampering
1012  * with the trust calculation.
1013  */
1014 static int
1015 import_secret_one( const char *fname, KBNODE keyblock, 
1016                    struct stats_s *stats, unsigned int options)
1017 {
1018     PKT_secret_key *sk;
1019     KBNODE node, uidnode;
1020     u32 keyid[2];
1021     int rc = 0;
1022
1023     /* get the key and print some info about it */
1024     node = find_kbnode( keyblock, PKT_SECRET_KEY );
1025     if( !node )
1026         BUG();
1027
1028     sk = node->pkt->pkt.secret_key;
1029     keyid_from_sk( sk, keyid );
1030     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
1031
1032     if( opt.verbose )
1033       {
1034         log_info( "sec  %4u%c/%s %s   ",
1035                   nbits_from_sk( sk ),
1036                   pubkey_letter( sk->pubkey_algo ),
1037                   keystr_from_sk(sk), datestr_from_sk(sk) );
1038         if( uidnode )
1039           print_utf8_string( stderr, uidnode->pkt->pkt.user_id->name,
1040                              uidnode->pkt->pkt.user_id->len );
1041         putc('\n', stderr);
1042       }
1043     stats->secret_read++;
1044
1045     if( !uidnode )
1046       {
1047         log_error( _("key %s: no user ID\n"), keystr_from_sk(sk));
1048         return 0;
1049       }
1050
1051     if(sk->protect.algo>110)
1052       {
1053         log_error(_("key %s: secret key with invalid cipher %d"
1054                     " - skipped\n"),keystr_from_sk(sk),sk->protect.algo);
1055         return 0;
1056       }
1057
1058     clear_kbnode_flags( keyblock );
1059
1060     /* do we have this key already in one of our secrings ? */
1061     rc = seckey_available( keyid );
1062     if( rc == G10ERR_NO_SECKEY && !(opt.import_options&IMPORT_MERGE_ONLY) )
1063       {
1064         /* simply insert this key */
1065         KEYDB_HANDLE hd = keydb_new (1);
1066
1067         /* get default resource */
1068         rc = keydb_locate_writable (hd, NULL);
1069         if (rc) {
1070           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
1071           keydb_release (hd);
1072           return G10ERR_GENERAL;
1073         }
1074         rc = keydb_insert_keyblock (hd, keyblock );
1075         if (rc)
1076           log_error (_("error writing keyring `%s': %s\n"),
1077                      keydb_get_resource_name (hd), g10_errstr(rc) );
1078         keydb_release (hd);
1079         /* we are ready */
1080         if( !opt.quiet )
1081           log_info( _("key %s: secret key imported\n"), keystr_from_sk(sk));
1082         stats->secret_imported++;
1083         if (is_status_enabled ()) 
1084           print_import_ok (NULL, sk, 1|16);
1085
1086         if(options&IMPORT_SK2PK)
1087           {
1088             /* Try and make a public key out of this. */
1089
1090             KBNODE pub_keyblock=sec_to_pub_keyblock(keyblock);
1091             if(pub_keyblock)
1092               {
1093                 import_one(fname,pub_keyblock,stats,opt.import_options);
1094                 release_kbnode(pub_keyblock);
1095               }
1096           }
1097
1098         /* Now that the key is definitely incorporated into the keydb,
1099            if we have the public part of this key, we need to check if
1100            the prefs are rational. */
1101         node=get_pubkeyblock(keyid);
1102         if(node)
1103           {
1104             check_prefs(node);
1105             release_kbnode(node);
1106           }
1107       }
1108     else if( !rc )
1109       { /* we can't merge secret keys */
1110         log_error( _("key %s: already in secret keyring\n"),
1111                    keystr_from_sk(sk));
1112         stats->secret_dups++;
1113         if (is_status_enabled ()) 
1114           print_import_ok (NULL, sk, 16);
1115
1116         /* TODO: if we ever do merge secret keys, make sure to handle
1117            the sec_to_pub_keyblock feature as well. */
1118       }
1119     else
1120       log_error( _("key %s: secret key not found: %s\n"),
1121                  keystr_from_sk(sk), g10_errstr(rc));
1122
1123     return rc;
1124 }
1125
1126
1127 /****************
1128  * Import a revocation certificate; this is a single signature packet.
1129  */
1130 static int
1131 import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
1132 {
1133     PKT_public_key *pk=NULL;
1134     KBNODE onode, keyblock = NULL;
1135     KEYDB_HANDLE hd = NULL;
1136     u32 keyid[2];
1137     int rc = 0;
1138
1139     assert( !node->next );
1140     assert( node->pkt->pkttype == PKT_SIGNATURE );
1141     assert( node->pkt->pkt.signature->sig_class == 0x20 );
1142
1143     keyid[0] = node->pkt->pkt.signature->keyid[0];
1144     keyid[1] = node->pkt->pkt.signature->keyid[1];
1145
1146     pk = m_alloc_clear( sizeof *pk );
1147     rc = get_pubkey( pk, keyid );
1148     if( rc == G10ERR_NO_PUBKEY )
1149       {
1150         log_error(_("key %s: no public key -"
1151                     " can't apply revocation certificate\n"), keystr(keyid));
1152         rc = 0;
1153         goto leave;
1154       }
1155     else if( rc )
1156       {
1157         log_error(_("key %s: public key not found: %s\n"),
1158                   keystr(keyid), g10_errstr(rc));
1159         goto leave;
1160       }
1161
1162     /* read the original keyblock */
1163     hd = keydb_new (0);
1164     {
1165         byte afp[MAX_FINGERPRINT_LEN];
1166         size_t an;
1167         
1168         fingerprint_from_pk (pk, afp, &an);
1169         while (an < MAX_FINGERPRINT_LEN) 
1170             afp[an++] = 0;
1171         rc = keydb_search_fpr (hd, afp);
1172     }
1173     if (rc)
1174       {
1175         log_error (_("key %s: can't locate original keyblock: %s\n"),
1176                    keystr(keyid), g10_errstr(rc));
1177         goto leave;
1178       }
1179     rc = keydb_get_keyblock (hd, &keyblock );
1180     if (rc)
1181       {
1182         log_error (_("key %s: can't read original keyblock: %s\n"),
1183                    keystr(keyid), g10_errstr(rc));
1184         goto leave;
1185       }
1186
1187     /* it is okay, that node is not in keyblock because
1188      * check_key_signature works fine for sig_class 0x20 in this
1189      * special case. */
1190     rc = check_key_signature( keyblock, node, NULL);
1191     if( rc )
1192       {
1193         log_error( _("key %s: invalid revocation certificate"
1194                      ": %s - rejected\n"), keystr(keyid), g10_errstr(rc));
1195         goto leave;
1196       }
1197
1198     /* check whether we already have this */
1199     for(onode=keyblock->next; onode; onode=onode->next ) {
1200         if( onode->pkt->pkttype == PKT_USER_ID )
1201             break;
1202         else if( onode->pkt->pkttype == PKT_SIGNATURE
1203                  && !cmp_signatures(node->pkt->pkt.signature,
1204                                     onode->pkt->pkt.signature))
1205           {
1206             rc = 0;
1207             goto leave; /* yes, we already know about it */
1208           }
1209     }
1210
1211
1212     /* insert it */
1213     insert_kbnode( keyblock, clone_kbnode(node), 0 );
1214
1215     /* and write the keyblock back */
1216     rc = keydb_update_keyblock (hd, keyblock );
1217     if (rc)
1218         log_error (_("error writing keyring `%s': %s\n"),
1219                    keydb_get_resource_name (hd), g10_errstr(rc) );
1220     keydb_release (hd); hd = NULL;
1221     /* we are ready */
1222     if( !opt.quiet )
1223       {
1224         char *p=get_user_id_native (keyid);
1225         log_info( _("key %s: \"%s\" revocation certificate imported\n"),
1226                   keystr(keyid),p);
1227         m_free(p);
1228       }
1229     stats->n_revoc++;
1230
1231     /* If the key we just revoked was ultimately trusted, remove its
1232        ultimate trust.  This doesn't stop the user from putting the
1233        ultimate trust back, but is a reasonable solution for now. */
1234     if(get_ownertrust(pk)==TRUST_ULTIMATE)
1235       clear_ownertrusts(pk);
1236
1237     revalidation_mark ();
1238
1239   leave:
1240     keydb_release (hd);
1241     release_kbnode( keyblock );
1242     free_public_key( pk );
1243     return rc;
1244 }
1245
1246
1247 /****************
1248  * loop over the keyblock and check all self signatures.
1249  * Mark all user-ids with a self-signature by setting flag bit 0.
1250  * Mark all user-ids with an invalid self-signature by setting bit 1.
1251  * This works also for subkeys, here the subkey is marked.  Invalid or
1252  * extra subkey sigs (binding or revocation) are marked for deletion.
1253  * non_self is set to true if there are any sigs other than self-sigs
1254  * in this keyblock.
1255  */
1256 static int
1257 chk_self_sigs( const char *fname, KBNODE keyblock,
1258                PKT_public_key *pk, u32 *keyid, int *non_self )
1259 {
1260     KBNODE n,knode=NULL;
1261     PKT_signature *sig;
1262     int rc;
1263     u32 bsdate=0,rsdate=0;
1264     KBNODE bsnode=NULL,rsnode=NULL;
1265
1266     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
1267       if(n->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1268         {
1269           knode=n;
1270           bsdate=0;
1271           rsdate=0;
1272           bsnode=NULL;
1273           rsnode=NULL;
1274           continue;
1275         }
1276       else if( n->pkt->pkttype != PKT_SIGNATURE )
1277             continue;
1278         sig = n->pkt->pkt.signature;
1279         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
1280
1281           /* This just caches the sigs for later use.  That way we
1282              import a fully-cached key which speeds things up. */
1283           if(!opt.no_sig_cache)
1284             check_key_signature(keyblock,n,NULL);
1285
1286             if( (sig->sig_class&~3) == 0x10 ) {
1287                 KBNODE unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
1288                 if( !unode )
1289                   {
1290                     log_error( _("key %s: no user ID for signature\n"),
1291                                keystr(keyid));
1292                     return -1;  /* the complete keyblock is invalid */
1293                   }
1294
1295                 /* If it hasn't been marked valid yet, keep trying */
1296                 if(!(unode->flag&1)) {
1297                   rc = check_key_signature( keyblock, n, NULL);
1298                   if( rc )
1299                     {
1300                       if( opt.verbose )
1301                         {
1302                           char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
1303                                       strlen(unode->pkt->pkt.user_id->name),0);
1304                           log_info( rc == G10ERR_PUBKEY_ALGO ?
1305                                     _("key %s: unsupported public key "
1306                                       "algorithm on user ID \"%s\"\n"):
1307                                     _("key %s: invalid self-signature "
1308                                       "on user ID \"%s\"\n"),
1309                                     keystr(keyid),p);
1310                           m_free(p);
1311                         }
1312                     }
1313                   else
1314                     unode->flag |= 1; /* mark that signature checked */
1315                 }
1316             }
1317             else if( sig->sig_class == 0x18 ) {
1318               /* Note that this works based solely on the timestamps
1319                  like the rest of gpg.  If the standard gets
1320                  revocation targets, this may need to be revised. */
1321
1322                 if( !knode )
1323                   {
1324                     if(opt.verbose)
1325                       log_info( _("key %s: no subkey for key binding\n"),
1326                                 keystr(keyid));
1327                     n->flag |= 4; /* delete this */
1328                   }
1329                 else
1330                   {
1331                     rc = check_key_signature( keyblock, n, NULL);
1332                     if( rc )
1333                       {
1334                         if(opt.verbose)
1335                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1336                                    _("key %s: unsupported public key"
1337                                      " algorithm\n"):
1338                                    _("key %s: invalid subkey binding\n"),
1339                                    keystr(keyid));
1340                         n->flag|=4;
1341                       }
1342                     else
1343                       {
1344                         /* It's valid, so is it newer? */
1345                         if(sig->timestamp>=bsdate) {
1346                           knode->flag |= 1;  /* the subkey is valid */
1347                           if(bsnode)
1348                             {
1349                               bsnode->flag|=4; /* Delete the last binding
1350                                                   sig since this one is
1351                                                   newer */
1352                               if(opt.verbose)
1353                                 log_info(_("key %s: removed multiple subkey"
1354                                            " binding\n"),keystr(keyid));
1355                             }
1356
1357                           bsnode=n;
1358                           bsdate=sig->timestamp;
1359                         }
1360                         else
1361                           n->flag|=4; /* older */
1362                       }
1363                   }
1364             }
1365             else if( sig->sig_class == 0x28 ) {
1366               /* We don't actually mark the subkey as revoked right
1367                  now, so just check that the revocation sig is the
1368                  most recent valid one.  Note that we don't care if
1369                  the binding sig is newer than the revocation sig.
1370                  See the comment in getkey.c:merge_selfsigs_subkey for
1371                  more */
1372                 if( !knode )
1373                   {
1374                     if(opt.verbose)
1375                       log_info( _("key %s: no subkey for key revocation\n"),
1376                                 keystr(keyid));
1377                     n->flag |= 4; /* delete this */
1378                   }
1379                 else
1380                   {
1381                     rc = check_key_signature( keyblock, n, NULL);
1382                     if( rc )
1383                       {
1384                         if(opt.verbose)
1385                           log_info(rc == G10ERR_PUBKEY_ALGO ?
1386                                    _("key %s: unsupported public"
1387                                      " key algorithm\n"):
1388                                    _("key %s: invalid subkey revocation\n"),
1389                                    keystr(keyid));
1390                         n->flag|=4;
1391                       }
1392                     else
1393                       {
1394                         /* It's valid, so is it newer? */
1395                         if(sig->timestamp>=rsdate)
1396                           {
1397                             if(rsnode)
1398                               {
1399                                 rsnode->flag|=4; /* Delete the last revocation
1400                                                     sig since this one is
1401                                                     newer */
1402                                 if(opt.verbose)
1403                                   log_info(_("key %s: removed multiple subkey"
1404                                              " revocation\n"),keystr(keyid));
1405                               }
1406
1407                             rsnode=n;
1408                             rsdate=sig->timestamp;
1409                           }
1410                         else
1411                           n->flag|=4; /* older */
1412                       }
1413                   }
1414             }
1415         }
1416         else
1417           *non_self=1;
1418     }
1419
1420     return 0;
1421 }
1422
1423 /****************
1424  * delete all parts which are invalid and those signatures whose
1425  * public key algorithm is not available in this implemenation;
1426  * but consider RSA as valid, because parse/build_packets knows
1427  * about it.
1428  * returns: true if at least one valid user-id is left over.
1429  */
1430 static int
1431 delete_inv_parts( const char *fname, KBNODE keyblock,
1432                   u32 *keyid, unsigned int options)
1433 {
1434     KBNODE node;
1435     int nvalid=0, uid_seen=0, subkey_seen=0;
1436
1437     for(node=keyblock->next; node; node = node->next ) {
1438         if( node->pkt->pkttype == PKT_USER_ID ) {
1439             uid_seen = 1;
1440             if( (node->flag & 2) || !(node->flag & 1) ) {
1441                 if( opt.verbose )
1442                   {
1443                     char *p=utf8_to_native(node->pkt->pkt.user_id->name,
1444                                            node->pkt->pkt.user_id->len,0);
1445                     log_info( _("key %s: skipped user ID \"%s\"\n"),
1446                               keystr(keyid),p);
1447                     m_free(p);
1448                   }
1449                 delete_kbnode( node ); /* the user-id */
1450                 /* and all following packets up to the next user-id */
1451                 while( node->next
1452                        && node->next->pkt->pkttype != PKT_USER_ID
1453                        && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
1454                        && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
1455                     delete_kbnode( node->next );
1456                     node = node->next;
1457                 }
1458             }
1459             else
1460                 nvalid++;
1461         }
1462         else if(    node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1463                  || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1464             if( (node->flag & 2) || !(node->flag & 1) ) {
1465                 if( opt.verbose )
1466                   log_info( _("key %s: skipped subkey\n"),keystr(keyid));
1467
1468                 delete_kbnode( node ); /* the subkey */
1469                 /* and all following signature packets */
1470                 while( node->next
1471                        && node->next->pkt->pkttype == PKT_SIGNATURE ) {
1472                     delete_kbnode( node->next );
1473                     node = node->next;
1474                 }
1475             }
1476             else
1477               subkey_seen = 1;
1478         }
1479         else if( node->pkt->pkttype == PKT_SIGNATURE
1480                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
1481                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
1482             delete_kbnode( node ); /* build_packet() can't handle this */
1483         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1484                  !node->pkt->pkt.signature->flags.exportable &&
1485                  !(options&IMPORT_ALLOW_LOCAL_SIGS) &&
1486                  seckey_available( node->pkt->pkt.signature->keyid ) )
1487           {
1488             /* here we violate the rfc a bit by still allowing
1489              * to import non-exportable signature when we have the
1490              * the secret key used to create this signature - it
1491              * seems that this makes sense */
1492             if(opt.verbose)
1493               log_info( _("key %s: non exportable signature"
1494                           " (class 0x%02X) - skipped\n"),
1495                         keystr(keyid), node->pkt->pkt.signature->sig_class );
1496             delete_kbnode( node );
1497           }
1498         else if( node->pkt->pkttype == PKT_SIGNATURE
1499                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1500             if( uid_seen )
1501               {
1502                 if(opt.verbose)
1503                   log_info( _("key %s: revocation certificate"
1504                               " at wrong place - skipped\n"),keystr(keyid));
1505                 delete_kbnode( node );
1506               }
1507             else {
1508               /* If the revocation cert is from a different key than
1509                  the one we're working on don't check it - it's
1510                  probably from a revocation key and won't be
1511                  verifiable with this key anyway. */
1512
1513               if(node->pkt->pkt.signature->keyid[0]==keyid[0] &&
1514                  node->pkt->pkt.signature->keyid[1]==keyid[1])
1515                 {
1516                   int rc = check_key_signature( keyblock, node, NULL);
1517                   if( rc )
1518                     {
1519                       if(opt.verbose)
1520                         log_info( _("key %s: invalid revocation"
1521                                     " certificate: %s - skipped\n"),
1522                                   keystr(keyid), g10_errstr(rc));
1523                       delete_kbnode( node );
1524                     }
1525                 }
1526             }
1527         }
1528         else if( node->pkt->pkttype == PKT_SIGNATURE &&
1529                  (node->pkt->pkt.signature->sig_class == 0x18 ||
1530                   node->pkt->pkt.signature->sig_class == 0x28) &&
1531                  !subkey_seen )
1532           {
1533             if(opt.verbose)
1534               log_info( _("key %s: subkey signature"
1535                           " in wrong place - skipped\n"), keystr(keyid));
1536             delete_kbnode( node );
1537           }
1538         else if( node->pkt->pkttype == PKT_SIGNATURE
1539                  && !IS_CERT(node->pkt->pkt.signature))
1540           {
1541             if(opt.verbose)
1542               log_info(_("key %s: unexpected signature class (0x%02X) -"
1543                          " skipped\n"),keystr(keyid),
1544                        node->pkt->pkt.signature->sig_class);
1545             delete_kbnode(node);
1546           }
1547         else if( (node->flag & 4) ) /* marked for deletion */
1548             delete_kbnode( node );
1549     }
1550
1551     /* note: because keyblock is the public key, it is never marked
1552      * for deletion and so keyblock cannot change */
1553     commit_kbnode( &keyblock );
1554     return nvalid;
1555 }
1556
1557
1558 /****************
1559  * It may happen that the imported keyblock has duplicated user IDs.
1560  * We check this here and collapse those user IDs together with their
1561  * sigs into one.
1562  * Returns: True if the keyblock hash changed.
1563  */
1564 int
1565 collapse_uids( KBNODE *keyblock )
1566 {
1567     KBNODE n, n2;
1568     int in_uid;
1569     int any=0;
1570
1571   restart:
1572     for( n = *keyblock; n; n = n->next ) {
1573         if( n->pkt->pkttype != PKT_USER_ID )
1574             continue;
1575         for( n2 = n->next; n2; n2 = n2->next ) {
1576             if( n2->pkt->pkttype == PKT_USER_ID
1577                 && !cmp_user_ids( n->pkt->pkt.user_id,
1578                                   n2->pkt->pkt.user_id ) ) {
1579                 /* found a duplicate */
1580                 any = 1;
1581                 if( !n2->next
1582                     || n2->next->pkt->pkttype == PKT_USER_ID
1583                     || n2->next->pkt->pkttype == PKT_PUBLIC_SUBKEY
1584                     || n2->next->pkt->pkttype == PKT_SECRET_SUBKEY  ) {
1585                     /* no more signatures: delete the user ID
1586                      * and start over */
1587                     remove_kbnode( keyblock, n2 );
1588                 }
1589                 else {
1590                     /* The simple approach: Move one signature and
1591                      * then start over to delete the next one :-( */
1592                     move_kbnode( keyblock, n2->next, n->next );
1593                 }
1594                 goto restart;
1595             }
1596         }
1597     }
1598     if( !any )
1599         return 0;
1600
1601   restart_sig:
1602     /* now we may have duplicate signatures on one user ID: fix this */
1603     for( in_uid = 0, n = *keyblock; n; n = n->next ) {
1604         if( n->pkt->pkttype == PKT_USER_ID )
1605             in_uid = 1;
1606         else if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1607                  || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1608             in_uid = 0;
1609         else if( in_uid ) {
1610             n2 = n;
1611             do {
1612                 KBNODE ncmp = NULL;
1613                 for( ; n2; n2 = n2->next ) {
1614                     if(    n2->pkt->pkttype == PKT_USER_ID
1615                         || n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
1616                         || n2->pkt->pkttype == PKT_SECRET_SUBKEY )
1617                         break;
1618                     if( n2->pkt->pkttype != PKT_SIGNATURE )
1619                         ;
1620                     else if( !ncmp )
1621                         ncmp = n2;
1622                     else if( !cmp_signatures( ncmp->pkt->pkt.signature,
1623                                                 n2->pkt->pkt.signature )) {
1624                         remove_kbnode( keyblock, n2 );
1625                         goto restart_sig;
1626                     }
1627                 }
1628                 n2 = ncmp? ncmp->next : NULL;
1629             } while( n2 );
1630         }
1631     }
1632
1633     if(!opt.quiet)
1634       {
1635         const char *key="???";
1636
1637         if( (n = find_kbnode( *keyblock, PKT_PUBLIC_KEY )) )
1638           key=keystr_from_pk(n->pkt->pkt.public_key);
1639         else if( (n = find_kbnode( *keyblock, PKT_SECRET_KEY )) )
1640           key=keystr_from_sk(n->pkt->pkt.secret_key);
1641
1642         log_info(_("key %s: duplicated user ID detected - merged\n"),key);
1643       }
1644
1645     return 1;
1646 }
1647
1648 /* Check for a 0x20 revocation from a revocation key that is not
1649    present.  This may be called without the benefit of merge_xxxx so
1650    you can't rely on pk->revkey and friends. */
1651 static void
1652 revocation_present(KBNODE keyblock)
1653 {
1654   KBNODE onode,inode;
1655   PKT_public_key *pk=keyblock->pkt->pkt.public_key;
1656
1657   for(onode=keyblock->next;onode;onode=onode->next)
1658     {
1659       /* If we reach user IDs, we're done. */
1660       if(onode->pkt->pkttype==PKT_USER_ID)
1661         break;
1662
1663       if(onode->pkt->pkttype==PKT_SIGNATURE &&
1664          onode->pkt->pkt.signature->sig_class==0x1F &&
1665          onode->pkt->pkt.signature->revkey)
1666         {
1667           int idx;
1668           PKT_signature *sig=onode->pkt->pkt.signature;
1669
1670           for(idx=0;idx<sig->numrevkeys;idx++)
1671             {
1672               u32 keyid[2];
1673
1674               keyid_from_fingerprint(sig->revkey[idx]->fpr,
1675                                      MAX_FINGERPRINT_LEN,keyid);
1676
1677               for(inode=keyblock->next;inode;inode=inode->next)
1678                 {
1679                   /* If we reach user IDs, we're done. */
1680                   if(inode->pkt->pkttype==PKT_USER_ID)
1681                     break;
1682
1683                   if(inode->pkt->pkttype==PKT_SIGNATURE &&
1684                      inode->pkt->pkt.signature->sig_class==0x20 &&
1685                      inode->pkt->pkt.signature->keyid[0]==keyid[0] &&
1686                      inode->pkt->pkt.signature->keyid[1]==keyid[1])
1687                     {
1688                       /* Okay, we have a revocation key, and a
1689                          revocation issued by it.  Do we have the key
1690                          itself? */
1691                       int rc;
1692
1693                       rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
1694                                                    MAX_FINGERPRINT_LEN);
1695                       if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1696                         {
1697                           char *tempkeystr=m_strdup(keystr_from_pk(pk));
1698
1699                           /* No, so try and get it */
1700                           if(opt.keyserver
1701                              && (opt.keyserver_options.options
1702                                  & KEYSERVER_AUTO_KEY_RETRIEVE))
1703                             {
1704                               log_info(_("WARNING: key %s may be revoked:"
1705                                          " fetching revocation key %s\n"),
1706                                        tempkeystr,keystr(keyid));
1707                               keyserver_import_fprint(sig->revkey[idx]->fpr,
1708                                                       MAX_FINGERPRINT_LEN,
1709                                                       opt.keyserver);
1710
1711                               /* Do we have it now? */
1712                               rc=get_pubkey_byfprint_fast (NULL,
1713                                                      sig->revkey[idx]->fpr,
1714                                                      MAX_FINGERPRINT_LEN);
1715                             }
1716
1717                           if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
1718                             log_info(_("WARNING: key %s may be revoked:"
1719                                        " revocation key %s not present.\n"),
1720                                      tempkeystr,keystr(keyid));
1721
1722                           m_free(tempkeystr);
1723                         }
1724                     }
1725                 }
1726             }
1727         }
1728     }
1729 }
1730
1731 /****************
1732  * compare and merge the blocks
1733  *
1734  * o compare the signatures: If we already have this signature, check
1735  *   that they compare okay; if not, issue a warning and ask the user.
1736  * o Simply add the signature.  Can't verify here because we may not have
1737  *   the signature's public key yet; verification is done when putting it
1738  *   into the trustdb, which is done automagically as soon as this pubkey
1739  *   is used.
1740  * Note: We indicate newly inserted packets with flag bit 0
1741  */
1742 static int
1743 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
1744               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
1745 {
1746     KBNODE onode, node;
1747     int rc, found;
1748
1749     /* 1st: handle revocation certificates */
1750     for(node=keyblock->next; node; node=node->next ) {
1751         if( node->pkt->pkttype == PKT_USER_ID )
1752             break;
1753         else if( node->pkt->pkttype == PKT_SIGNATURE
1754                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
1755             /* check whether we already have this */
1756             found = 0;
1757             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1758                 if( onode->pkt->pkttype == PKT_USER_ID )
1759                     break;
1760                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1761                          && onode->pkt->pkt.signature->sig_class == 0x20
1762                          && !cmp_signatures(onode->pkt->pkt.signature,
1763                                             node->pkt->pkt.signature))
1764                   {
1765                     found = 1;
1766                     break;
1767                   }
1768             }
1769             if( !found ) {
1770                 KBNODE n2 = clone_kbnode(node);
1771                 insert_kbnode( keyblock_orig, n2, 0 );
1772                 n2->flag |= 1;
1773                 ++*n_sigs;
1774                 if(!opt.quiet)
1775                   {
1776                     char *p=get_user_id_native (keyid);
1777                     log_info(_("key %s: \"%s\" revocation"
1778                                " certificate added\n"), keystr(keyid),p);
1779                     m_free(p);
1780                   }
1781             }
1782         }
1783     }
1784
1785     /* 2nd: merge in any direct key (0x1F) sigs */
1786     for(node=keyblock->next; node; node=node->next ) {
1787         if( node->pkt->pkttype == PKT_USER_ID )
1788             break;
1789         else if( node->pkt->pkttype == PKT_SIGNATURE
1790                  && node->pkt->pkt.signature->sig_class == 0x1F )  {
1791             /* check whether we already have this */
1792             found = 0;
1793             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1794                 if( onode->pkt->pkttype == PKT_USER_ID )
1795                     break;
1796                 else if( onode->pkt->pkttype == PKT_SIGNATURE
1797                          && onode->pkt->pkt.signature->sig_class == 0x1F
1798                          && !cmp_signatures(onode->pkt->pkt.signature,
1799                                             node->pkt->pkt.signature)) {
1800                     found = 1;
1801                     break;
1802                 }
1803             }
1804             if( !found )
1805               {
1806                 KBNODE n2 = clone_kbnode(node);
1807                 insert_kbnode( keyblock_orig, n2, 0 );
1808                 n2->flag |= 1;
1809                 ++*n_sigs;
1810                 if(!opt.quiet)
1811                   log_info( _("key %s: direct key signature added\n"),
1812                             keystr(keyid));
1813               }
1814         }
1815     }
1816
1817     /* 3rd: try to merge new certificates in */
1818     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1819         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
1820             /* find the user id in the imported keyblock */
1821             for(node=keyblock->next; node; node=node->next )
1822                 if( node->pkt->pkttype == PKT_USER_ID
1823                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1824                                           node->pkt->pkt.user_id ) )
1825                     break;
1826             if( node ) { /* found: merge */
1827                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
1828                 if( rc )
1829                     return rc;
1830             }
1831         }
1832     }
1833
1834     /* 4th: add new user-ids */
1835     for(node=keyblock->next; node; node=node->next ) {
1836         if( node->pkt->pkttype == PKT_USER_ID) {
1837             /* do we have this in the original keyblock */
1838             for(onode=keyblock_orig->next; onode; onode=onode->next )
1839                 if( onode->pkt->pkttype == PKT_USER_ID
1840                     && !cmp_user_ids( onode->pkt->pkt.user_id,
1841                                       node->pkt->pkt.user_id ) )
1842                     break;
1843             if( !onode ) { /* this is a new user id: append */
1844                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
1845                 if( rc )
1846                     return rc;
1847                 ++*n_uids;
1848             }
1849         }
1850     }
1851
1852     /* 5th: add new subkeys */
1853     for(node=keyblock->next; node; node=node->next ) {
1854         onode = NULL;
1855         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1856             /* do we have this in the original keyblock? */
1857             for(onode=keyblock_orig->next; onode; onode=onode->next )
1858                 if( onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1859                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1860                                          node->pkt->pkt.public_key ) )
1861                     break;
1862             if( !onode ) { /* this is a new subkey: append */
1863                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1864                 if( rc )
1865                     return rc;
1866                 ++*n_subk;
1867             }
1868         }
1869         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1870             /* do we have this in the original keyblock? */
1871             for(onode=keyblock_orig->next; onode; onode=onode->next )
1872                 if( onode->pkt->pkttype == PKT_SECRET_SUBKEY
1873                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1874                                          node->pkt->pkt.secret_key ) )
1875                     break;
1876             if( !onode ) { /* this is a new subkey: append */
1877                 rc = append_key( keyblock_orig, node, n_sigs, fname, keyid);
1878                 if( rc )
1879                     return rc;
1880                 ++*n_subk;
1881             }
1882         }
1883     }
1884
1885     /* 6th: merge subkey certificates */
1886     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
1887         if( !(onode->flag & 1)
1888             &&  (   onode->pkt->pkttype == PKT_PUBLIC_SUBKEY
1889                  || onode->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
1890             /* find the subkey in the imported keyblock */
1891             for(node=keyblock->next; node; node=node->next ) {
1892                 if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1893                     && !cmp_public_keys( onode->pkt->pkt.public_key,
1894                                           node->pkt->pkt.public_key ) )
1895                     break;
1896                 else if( node->pkt->pkttype == PKT_SECRET_SUBKEY
1897                     && !cmp_secret_keys( onode->pkt->pkt.secret_key,
1898                                           node->pkt->pkt.secret_key ) )
1899                     break;
1900             }
1901             if( node ) { /* found: merge */
1902                 rc = merge_keysigs( onode, node, n_sigs, fname, keyid );
1903                 if( rc )
1904                     return rc;
1905             }
1906         }
1907     }
1908
1909
1910     return 0;
1911 }
1912
1913
1914 /****************
1915  * append the userid starting with NODE and all signatures to KEYBLOCK.
1916  */
1917 static int
1918 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
1919                                           const char *fname, u32 *keyid )
1920 {
1921     KBNODE n, n_where=NULL;
1922
1923     assert(node->pkt->pkttype == PKT_USER_ID );
1924
1925     /* find the position */
1926     for( n = keyblock; n; n_where = n, n = n->next ) {
1927         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
1928             || n->pkt->pkttype == PKT_SECRET_SUBKEY )
1929             break;
1930     }
1931     if( !n )
1932         n_where = NULL;
1933
1934     /* and append/insert */
1935     while( node ) {
1936         /* we add a clone to the original keyblock, because this
1937          * one is released first */
1938         n = clone_kbnode(node);
1939         if( n_where ) {
1940             insert_kbnode( n_where, n, 0 );
1941             n_where = n;
1942         }
1943         else
1944             add_kbnode( keyblock, n );
1945         n->flag |= 1;
1946         node->flag |= 1;
1947         if( n->pkt->pkttype == PKT_SIGNATURE )
1948             ++*n_sigs;
1949
1950         node = node->next;
1951         if( node && node->pkt->pkttype != PKT_SIGNATURE )
1952             break;
1953     }
1954
1955     return 0;
1956 }
1957
1958
1959 /****************
1960  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
1961  * (how should we handle comment packets here?)
1962  */
1963 static int
1964 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
1965                                     const char *fname, u32 *keyid )
1966 {
1967     KBNODE n, n2;
1968     int found=0;
1969
1970     assert(dst->pkt->pkttype == PKT_USER_ID );
1971     assert(src->pkt->pkttype == PKT_USER_ID );
1972
1973     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
1974         if( n->pkt->pkttype != PKT_SIGNATURE )
1975             continue;
1976         if( n->pkt->pkt.signature->sig_class == 0x18
1977             || n->pkt->pkt.signature->sig_class == 0x28 )
1978             continue; /* skip signatures which are only valid on subkeys */
1979         found = 0;
1980         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
1981           if(!cmp_signatures(n->pkt->pkt.signature,n2->pkt->pkt.signature))
1982             {
1983               found++;
1984               break;
1985             }
1986         if( !found ) {
1987             /* This signature is new or newer, append N to DST.
1988              * We add a clone to the original keyblock, because this
1989              * one is released first */
1990             n2 = clone_kbnode(n);
1991             insert_kbnode( dst, n2, PKT_SIGNATURE );
1992             n2->flag |= 1;
1993             n->flag |= 1;
1994             ++*n_sigs;
1995         }
1996     }
1997
1998     return 0;
1999 }
2000
2001 /****************
2002  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_xxx_SUBKEY.
2003  */
2004 static int
2005 merge_keysigs( KBNODE dst, KBNODE src, int *n_sigs,
2006                                     const char *fname, u32 *keyid )
2007 {
2008     KBNODE n, n2;
2009     int found=0;
2010
2011     assert(   dst->pkt->pkttype == PKT_PUBLIC_SUBKEY
2012            || dst->pkt->pkttype == PKT_SECRET_SUBKEY );
2013
2014     for(n=src->next; n ; n = n->next ) {
2015         if( n->pkt->pkttype == PKT_PUBLIC_SUBKEY
2016             || n->pkt->pkttype == PKT_PUBLIC_KEY )
2017             break;
2018         if( n->pkt->pkttype != PKT_SIGNATURE )
2019             continue;
2020         found = 0;
2021         for(n2=dst->next; n2; n2 = n2->next){
2022             if( n2->pkt->pkttype == PKT_PUBLIC_SUBKEY
2023                 || n2->pkt->pkttype == PKT_PUBLIC_KEY )
2024                 break;
2025             if( n2->pkt->pkttype == PKT_SIGNATURE
2026                 && n->pkt->pkt.signature->keyid[0]
2027                    == n2->pkt->pkt.signature->keyid[0]
2028                 && n->pkt->pkt.signature->keyid[1]
2029                    == n2->pkt->pkt.signature->keyid[1]
2030                 && n->pkt->pkt.signature->timestamp
2031                    <= n2->pkt->pkt.signature->timestamp
2032                 && n->pkt->pkt.signature->sig_class
2033                    == n2->pkt->pkt.signature->sig_class ) {
2034                 found++;
2035                 break;
2036             }
2037         }
2038         if( !found ) {
2039             /* This signature is new or newer, append N to DST.
2040              * We add a clone to the original keyblock, because this
2041              * one is released first */
2042             n2 = clone_kbnode(n);
2043             insert_kbnode( dst, n2, PKT_SIGNATURE );
2044             n2->flag |= 1;
2045             n->flag |= 1;
2046             ++*n_sigs;
2047         }
2048     }
2049
2050     return 0;
2051 }
2052
2053 /****************
2054  * append the subkey starting with NODE and all signatures to KEYBLOCK.
2055  * Mark all new and copied packets by setting flag bit 0.
2056  */
2057 static int
2058 append_key( KBNODE keyblock, KBNODE node, int *n_sigs,
2059                                           const char *fname, u32 *keyid )
2060 {
2061     KBNODE n;
2062
2063     assert( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2064            || node->pkt->pkttype == PKT_SECRET_SUBKEY );
2065
2066     while(  node ) {
2067         /* we add a clone to the original keyblock, because this
2068          * one is released first */
2069         n = clone_kbnode(node);
2070         add_kbnode( keyblock, n );
2071         n->flag |= 1;
2072         node->flag |= 1;
2073         if( n->pkt->pkttype == PKT_SIGNATURE )
2074             ++*n_sigs;
2075
2076         node = node->next;
2077         if( node && node->pkt->pkttype != PKT_SIGNATURE )
2078             break;
2079     }
2080
2081     return 0;
2082 }