add-key works
[gnupg.git] / g10 / import.c
1 /* import.c
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <assert.h>
27
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "keydb.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "main.h"
36
37
38 static int read_block( IOBUF a, compress_filter_context_t *cfx,
39                              PACKET **pending_pkt, KBNODE *ret_root );
40 static int import_one( const char *fname, KBNODE keyblock );
41 static int import_revoke_cert( const char *fname, KBNODE node );
42 static int chk_self_sigs( const char *fname, KBNODE keyblock,
43                           PKT_public_cert *pkc, u32 *keyid );
44 static int delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid );
45 static int merge_blocks( const char *fname, KBNODE keyblock_orig,
46                          KBNODE keyblock, u32 *keyid,
47                          int *n_uids, int *n_sigs, int *n_subk );
48 static int append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
49                              const char *fname, u32 *keyid );
50 static int merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
51                              const char *fname, u32 *keyid );
52
53
54 /****************
55  * Import the public keys from the given filename. Input may be armored.
56  * This function rejects all keys which are not validly self signed on at
57  * least one userid. Only user ids which are self signed will be imported.
58  * Other signatures are not checked.
59  *
60  * Actually this functtion does a merge. It works like this:
61  *
62  *  - get the keyblock
63  *  - check self-signatures and remove all userids and their signatures
64  *    without/invalid self-signatures.
65  *  - reject the keyblock, if we have no valid userid.
66  *  - See whether we have this key already in one of our pubrings.
67  *    If not, simply add it to the default keyring.
68  *  - Compare the key and the self-signatures of the new and the one in
69  *    our keyring.  If they are different something weird is going on;
70  *    ask what to do.
71  *  - See whether we have only non-self-signature on one user id; if not
72  *    ask the user what to do.
73  *  - compare the signatures: If we already have this signature, check
74  *    that they compare okay; if not, issue a warning and ask the user.
75  *    (consider looking at the timestamp and use the newest?)
76  *  - Simply add the signature.  Can't verify here because we may not have
77  *    the signature's public key yet; verification is done when putting it
78  *    into the trustdb, which is done automagically as soon as this pubkey
79  *    is used.
80  *  - Proceed with next signature.
81  *
82  *  Key revocation certificates have special handling.
83  *
84  */
85 int
86 import_pubkeys( const char *fname )
87 {
88     armor_filter_context_t afx;
89     compress_filter_context_t cfx;
90     PACKET *pending_pkt = NULL;
91     IOBUF inp = NULL;
92     KBNODE keyblock;
93     int rc = 0;
94
95     memset( &afx, 0, sizeof afx);
96     memset( &cfx, 0, sizeof cfx);
97
98     /* open file */
99     inp = iobuf_open(fname);
100     if( !fname )
101         fname = "[stdin]";
102     if( !inp ) {
103         log_error("%s: can't open file: %s\n", fname, strerror(errno) );
104         return G10ERR_OPEN_FILE;
105     }
106
107     if( !opt.no_armor ) /* armored reading is not disabled */
108         iobuf_push_filter( inp, armor_filter, &afx );
109
110     while( !(rc = read_block( inp, &cfx, &pending_pkt, &keyblock) )) {
111         if( keyblock->pkt->pkttype == PKT_PUBLIC_CERT )
112             rc = import_one( fname, keyblock );
113         else if( keyblock->pkt->pkttype == PKT_SIGNATURE
114                  && keyblock->pkt->pkt.signature->sig_class == 0x20 )
115             rc = import_revoke_cert( fname, keyblock );
116         else
117             log_info("%s: skipping block of type %d\n",
118                                             fname, keyblock->pkt->pkttype );
119         release_kbnode(keyblock);
120         if( rc )
121             break;
122     }
123     if( rc == -1 )
124         rc = 0;
125     else if( rc )
126         log_error("%s: read error: %s\n", fname, g10_errstr(rc));
127
128     iobuf_close(inp);
129     return rc;
130 }
131
132
133 /****************
134  * Read the next keyblock from stream A, CFX is used to handle
135  * compressed keyblocks. PENDING_PKT should be initialzed to NULL
136  * and not chnaged form the caller.
137  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
138  */
139 static int
140 read_block( IOBUF a, compress_filter_context_t *cfx,
141             PACKET **pending_pkt, KBNODE *ret_root )
142 {
143     int rc;
144     PACKET *pkt;
145     KBNODE root = NULL;
146     int in_cert;
147
148     if( *pending_pkt ) {
149         root = new_kbnode( *pending_pkt );
150         *pending_pkt = NULL;
151         in_cert = 1;
152     }
153     else
154         in_cert = 0;
155     pkt = m_alloc( sizeof *pkt );
156     init_packet(pkt);
157     while( (rc=parse_packet(a, pkt)) != -1 ) {
158         if( rc ) {  /* ignore errors */
159             if( rc != G10ERR_UNKNOWN_PACKET ) {
160                 log_error("read_block: read error: %s\n", g10_errstr(rc) );
161                 rc = G10ERR_INV_KEYRING;
162                 goto ready;
163             }
164             free_packet( pkt );
165             init_packet(pkt);
166             continue;
167         }
168
169         if( !root && pkt->pkttype == PKT_SIGNATURE
170                   && pkt->pkt.signature->sig_class == 0x20 ) {
171             /* this is a revocation certificate which is handled
172              * in a special way */
173             root = new_kbnode( pkt );
174             pkt = NULL;
175             goto ready;
176         }
177
178         /* make a linked list of all packets */
179         switch( pkt->pkttype ) {
180           case PKT_COMPRESSED:
181             if( pkt->pkt.compressed->algorithm < 1
182                 || pkt->pkt.compressed->algorithm > 2 ) {
183                 rc = G10ERR_COMPR_ALGO;
184                 goto ready;
185             }
186             cfx->algo = pkt->pkt.compressed->algorithm;
187             pkt->pkt.compressed->buf = NULL;
188             iobuf_push_filter( a, compress_filter, cfx );
189             free_packet( pkt );
190             init_packet(pkt);
191             break;
192
193
194           case PKT_PUBLIC_CERT:
195           case PKT_SECRET_CERT:
196             if( in_cert ) { /* store this packet */
197                 *pending_pkt = pkt;
198                 pkt = NULL;
199                 goto ready;
200             }
201             in_cert = 1;
202           default:
203             if( in_cert ) {
204                 if( !root )
205                     root = new_kbnode( pkt );
206                 else
207                     add_kbnode( root, new_kbnode( pkt ) );
208                 pkt = m_alloc( sizeof *pkt );
209             }
210             init_packet(pkt);
211             break;
212         }
213     }
214   ready:
215     if( rc == -1 && root )
216         rc = 0;
217
218     if( rc )
219         release_kbnode( root );
220     else
221         *ret_root = root;
222     free_packet( pkt );
223     m_free( pkt );
224     return rc;
225 }
226
227
228 /****************
229  * Try to import one keyblock.  Return an error only in serious cases, but
230  * never for an invalid keyblock.  It uses log_error to increase the
231  * internal errorcount, so that invalid input can be detected by programs
232  * which called g10.
233  */
234 static int
235 import_one( const char *fname, KBNODE keyblock )
236 {
237     PKT_public_cert *pkc;
238     PKT_public_cert *pkc_orig;
239     KBNODE node, uidnode;
240     KBNODE keyblock_orig = NULL;
241     KBPOS kbpos;
242     u32 keyid[2];
243     int rc = 0;
244
245     /* get the key and print some info about it */
246     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
247     if( !node ) {
248         log_error("%s: Oops; public key not found anymore!\n", fname);
249         return G10ERR_GENERAL; /* really serious */
250     }
251
252     pkc = node->pkt->pkt.public_cert;
253     keyid_from_pkc( pkc, keyid );
254     uidnode = find_next_kbnode( keyblock, PKT_USER_ID );
255
256     if( opt.verbose ) {
257         log_info("%s: pub  %4u%c/%08lX %s   ", fname,
258                   nbits_from_pkc( pkc ),
259                   pubkey_letter( pkc->pubkey_algo ),
260                   (ulong)keyid[1], datestr_from_pkc(pkc) );
261         if( uidnode )
262             print_string( stderr, uidnode->pkt->pkt.user_id->name,
263                                   uidnode->pkt->pkt.user_id->len, 0 );
264         putc('\n', stderr);
265     }
266     if( !uidnode ) {
267         log_error("%s: No user id for key %08lX\n", fname, (ulong)keyid[1]);
268         return 0;
269     }
270
271     clear_kbnode_flags( keyblock );
272     rc = chk_self_sigs( fname, keyblock , pkc, keyid );
273     if( rc )
274         return rc== -1? 0:rc;
275
276     if( !delete_inv_parts( fname, keyblock, keyid ) ) {
277         log_info("%s: key %08lX, no valid user ids\n",
278                                                     fname, (ulong)keyid[1]);
279         return 0;
280     }
281
282     /* do we have this key already in one of our pubrings ? */
283     pkc_orig = m_alloc_clear( sizeof *pkc_orig );
284     rc = get_pubkey( pkc_orig, keyid );
285     if( rc && rc != G10ERR_NO_PUBKEY ) {
286         log_error("%s: key %08lX, public key not found: %s\n",
287                                 fname, (ulong)keyid[1], g10_errstr(rc));
288     }
289     else if( rc ) { /* insert this key */
290         /* get default resource */
291         if( get_keyblock_handle( NULL, 0, &kbpos ) ) {
292             log_error("no default public keyring\n");
293             return G10ERR_GENERAL;
294         }
295         if( opt.verbose > 1 )
296             log_info("%s: writing to '%s'\n",
297                                 fname, keyblock_resource_name(&kbpos) );
298         if( (rc=lock_keyblock( &kbpos )) )
299             log_error("can't lock public keyring '%s': %s\n",
300                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
301         else if( (rc=insert_keyblock( &kbpos, keyblock )) )
302             log_error("%s: can't write to '%s': %s\n", fname,
303                              keyblock_resource_name(&kbpos), g10_errstr(rc) );
304         unlock_keyblock( &kbpos );
305         /* we are ready */
306         log_info("%s: key %08lX imported\n", fname, (ulong)keyid[1]);
307     }
308     else { /* merge */
309         int n_uids, n_sigs, n_subk;
310
311         /* Compare the original against the new key; just to be sure nothing
312          * weird is going on */
313         if( cmp_public_certs( pkc_orig, pkc ) ) {
314             log_error("%s: key %08lX, doesn't match our copy\n",
315                                                     fname, (ulong)keyid[1]);
316             rc = G10ERR_GENERAL;
317             goto leave;
318         }
319
320         /* See whether we have only non-self-signature on one user id; if not
321          * ask the user what to do. <--- fixme */
322
323         /* now read the original keyblock */
324         rc = find_keyblock_bypkc( &kbpos, pkc_orig );
325         if( rc ) {
326             log_error("%s: key %08lX, can't locate original keyblock: %s\n",
327                                      fname, (ulong)keyid[1], g10_errstr(rc));
328             goto leave;
329         }
330         rc = read_keyblock( &kbpos, &keyblock_orig );
331         if( rc ) {
332             log_error("%s: key %08lX, can't read original keyblock: %s\n",
333                                      fname, (ulong)keyid[1], g10_errstr(rc));
334             goto leave;
335         }
336         /* and try to merge the block */
337         clear_kbnode_flags( keyblock_orig );
338         clear_kbnode_flags( keyblock );
339         n_uids = n_sigs = n_subk = 0;
340         rc = merge_blocks( fname, keyblock_orig, keyblock,
341                                 keyid, &n_uids, &n_sigs, &n_subk );
342         if( rc )
343             goto leave;
344         if( n_uids || n_sigs || n_subk ) {
345             /* keyblock_orig has been updated; write */
346             if( opt.verbose > 1 )
347                 log_info("%s: writing to '%s'\n",
348                                     fname, keyblock_resource_name(&kbpos) );
349             if( (rc=lock_keyblock( &kbpos )) )
350                 log_error("can't lock public keyring '%s': %s\n",
351                                  keyblock_resource_name(&kbpos), g10_errstr(rc) );
352             else if( (rc=update_keyblock( &kbpos, keyblock )) )
353                 log_error("%s: can't write to '%s': %s\n", fname,
354                                  keyblock_resource_name(&kbpos), g10_errstr(rc) );
355             unlock_keyblock( &kbpos );
356             /* we are ready */
357             if( n_uids == 1 )
358                 log_info("%s: key %08lX, 1 new user-id\n",
359                                          fname, (ulong)keyid[1]);
360             else if( n_uids )
361                 log_info("%s: key %08lX, %d new user-ids\n",
362                                          fname, (ulong)keyid[1], n_uids );
363             if( n_sigs == 1 )
364                 log_info("%s: key %08lX, 1 new signature\n",
365                                          fname, (ulong)keyid[1]);
366             else if( n_sigs )
367                 log_info("%s: key %08lX, %d new signatures\n",
368                                          fname, (ulong)keyid[1], n_sigs );
369             if( n_subk == 1 )
370                 log_info("%s: key %08lX, 1 new subkey\n",
371                                          fname, (ulong)keyid[1]);
372             else if( n_subk )
373                 log_info("%s: key %08lX, %d new subkeys\n",
374                                          fname, (ulong)keyid[1], n_subk );
375         }
376         else
377             log_info("%s: key %08lX, not changed\n", fname, (ulong)keyid[1] );
378     }
379
380   leave:
381     release_kbnode( keyblock_orig );
382     free_public_cert( pkc_orig );
383     return rc;
384 }
385
386
387 /****************
388  * Import a revocation certificate; this is a single signature packet.
389  */
390 static int
391 import_revoke_cert( const char *fname, KBNODE node )
392 {
393     PKT_public_cert *pkc=NULL;
394     KBNODE onode, keyblock = NULL;
395     KBPOS kbpos;
396     u32 keyid[2];
397     int rc = 0;
398
399     assert( !node->next );
400     assert( node->pkt->pkttype == PKT_SIGNATURE );
401     assert( node->pkt->pkt.signature->sig_class == 0x20 );
402
403     keyid[0] = node->pkt->pkt.signature->keyid[0];
404     keyid[1] = node->pkt->pkt.signature->keyid[1];
405
406     pkc = m_alloc_clear( sizeof *pkc );
407     rc = get_pubkey( pkc, keyid );
408     if( rc == G10ERR_NO_PUBKEY ) {
409         log_info("%s: key %08lX, no public key - "
410                  "can't apply revocation certificate\n",
411                                 fname, (ulong)keyid[1]);
412         rc = 0;
413         goto leave;
414     }
415     else if( rc ) {
416         log_error("%s: key %08lX, public key not found: %s\n",
417                                 fname, (ulong)keyid[1], g10_errstr(rc));
418         goto leave;
419     }
420
421     /* read the original keyblock */
422     rc = find_keyblock_bypkc( &kbpos, pkc );
423     if( rc ) {
424         log_error("%s: key %08lX, can't locate original keyblock: %s\n",
425                                  fname, (ulong)keyid[1], g10_errstr(rc));
426         goto leave;
427     }
428     rc = read_keyblock( &kbpos, &keyblock );
429     if( rc ) {
430         log_error("%s: key %08lX, can't read original keyblock: %s\n",
431                                  fname, (ulong)keyid[1], g10_errstr(rc));
432         goto leave;
433     }
434
435
436     /* it is okay, that node is not in keyblock because
437      * check_key_signature works fine for sig_class 0x20 in this
438      * special case. */
439     rc = check_key_signature( keyblock, node, NULL);
440     if( rc ) {
441         log_error("%s: key %08lX, invalid revocation certificate"
442                   ": %s - rejected\n",
443                   fname, (ulong)keyid[1], g10_errstr(rc));
444     }
445
446
447     /* check whether we already have this */
448     for(onode=keyblock->next; onode; onode=onode->next ) {
449         if( onode->pkt->pkttype == PKT_USER_ID )
450             break;
451         else if( onode->pkt->pkttype == PKT_SIGNATURE
452                  && onode->pkt->pkt.signature->sig_class == 0x20
453                  && keyid[0] == onode->pkt->pkt.signature->keyid[0]
454                  && keyid[1] == onode->pkt->pkt.signature->keyid[1] ) {
455             rc = 0;
456             goto leave; /* yes, we already know about it */
457         }
458     }
459
460
461     /* insert it */
462     insert_kbnode( keyblock, clone_kbnode(node), 0 );
463
464     /* and write the keyblock back */
465     if( opt.verbose > 1 )
466         log_info("%s: writing to '%s'\n",
467                             fname, keyblock_resource_name(&kbpos) );
468     if( (rc=lock_keyblock( &kbpos )) )
469         log_error("can't lock public keyring '%s': %s\n",
470                          keyblock_resource_name(&kbpos), g10_errstr(rc) );
471     else if( (rc=update_keyblock( &kbpos, keyblock )) )
472         log_error("%s: can't write to '%s': %s\n", fname,
473                          keyblock_resource_name(&kbpos), g10_errstr(rc) );
474     unlock_keyblock( &kbpos );
475     /* we are ready */
476     log_info("%s: key %08lX, added revocation certificate\n",
477                                  fname, (ulong)keyid[1]);
478
479   leave:
480     release_kbnode( keyblock );
481     free_public_cert( pkc );
482     return rc;
483 }
484
485
486 /****************
487  * loop over the keyblock and check all self signatures.
488  * Mark all user-ids with a self-signature by setting flag bit 0.
489  * Mark all user-ids with an invalid self-signature by setting bit 1.
490  */
491 static int
492 chk_self_sigs( const char *fname, KBNODE keyblock,
493                PKT_public_cert *pkc, u32 *keyid )
494 {
495     KBNODE n, unode;
496     PKT_signature *sig;
497     int rc;
498
499     for( n=keyblock; (n = find_next_kbnode(n, 0)); ) {
500         if( n->pkt->pkttype != PKT_SIGNATURE )
501             continue;
502         sig = n->pkt->pkt.signature;
503         if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] ) {
504             unode = find_prev_kbnode( keyblock, n, PKT_USER_ID );
505             if( !unode )  {
506                 log_error("%s: key %08lX, no user-id for signature\n",
507                                         fname, (ulong)keyid[1]);
508                 return -1;  /* the complete keyblock is invalid */
509             }
510             rc = check_key_signature( keyblock, n, NULL);
511             if( rc ) {
512                 log_error( rc == G10ERR_PUBKEY_ALGO ?
513                           "%s: key %08lX, unsupported public key algorithm\n":
514                           "%s: key %08lX, invalid self-signature\n",
515                           fname, (ulong)keyid[1]);
516
517                 unode->flag |= 2; /* mark as invalid */
518             }
519             unode->flag |= 1; /* mark that user-id checked */
520         }
521     }
522     return 0;
523 }
524
525 /****************
526  * delete all parts which are invalid and those signatures whose
527  * public key algorithm is not available in this implemenation;
528  * but consider RSA as valid, because parse/build_packets knows
529  * about it.
530  * returns: true if at least one valid user-id is left over.
531  */
532 static int
533 delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
534 {
535     KBNODE node;
536     int nvalid=0, uid_seen=0;
537
538     for(node=keyblock->next; node; node = node->next ) {
539         if( node->pkt->pkttype == PKT_USER_ID ) {
540             uid_seen = 1;
541             if( (node->flag & 2) || !(node->flag & 1) ) {
542                 if( opt.verbose ) {
543                     log_info("%s: key %08lX, removed userid '",
544                                                   fname, (ulong)keyid[1]);
545                     print_string( stderr, node->pkt->pkt.user_id->name,
546                                       node->pkt->pkt.user_id->len, 0 );
547                     fputs("'\n", stderr );
548                 }
549                 delete_kbnode( node ); /* the user-id */
550                 /* and all following packets up to the next user-id */
551                 while( node->next && node->next->pkt->pkttype != PKT_USER_ID ){
552                     delete_kbnode( node->next );
553                     node = node->next;
554                 }
555             }
556             else
557                 nvalid++;
558         }
559         else if( node->pkt->pkttype == PKT_SIGNATURE
560                  && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
561                  && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
562             delete_kbnode( node ); /* build_packet() can't handle this */
563         else if( node->pkt->pkttype == PKT_SIGNATURE
564                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
565             if( uid_seen ) {
566                 log_error("%s: key %08lX, revocation certificate at wrong "
567                            "place - removed\n", fname, (ulong)keyid[1]);
568                 delete_kbnode( node );
569             }
570             else {
571                 int rc = check_key_signature( keyblock, node, NULL);
572                 if( rc ) {
573                     log_error("%s: key %08lX, invalid revocation certificate"
574                               ": %s - removed\n",
575                               fname, (ulong)keyid[1], g10_errstr(rc));
576                     delete_kbnode( node );
577                 }
578             }
579         }
580     }
581
582     /* note: because keyblock is the public key, it is never marked
583      * for deletion and so keyblock cannot change */
584     commit_kbnode( &keyblock );
585     return nvalid;
586 }
587
588
589 /****************
590  * compare and merge the blocks
591  *
592  * o compare the signatures: If we already have this signature, check
593  *   that they compare okay; if not, issue a warning and ask the user.
594  *   FIXME: add the check that we don't have duplicate signatures and the
595  *   warning in cases where the old/new signatures don't match.
596  * o Simply add the signature.  Can't verify here because we may not have
597  *   the signature's public key yet; verification is done when putting it
598  *   into the trustdb, which is done automagically as soon as this pubkey
599  *   is used.
600  * Note: We indicate newly inserted packets with flag bit 0
601  */
602 static int
603 merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
604               u32 *keyid, int *n_uids, int *n_sigs, int *n_subk )
605 {
606     KBNODE onode, node;
607     int rc, found;
608
609     /* 1st: handle revocation certificates */
610     for(node=keyblock->next; node; node=node->next ) {
611         if( node->pkt->pkttype == PKT_USER_ID )
612             break;
613         else if( node->pkt->pkttype == PKT_SIGNATURE
614                  && node->pkt->pkt.signature->sig_class == 0x20 )  {
615             /* check whether we already have this */
616             found = 0;
617             for(onode=keyblock_orig->next; onode; onode=onode->next ) {
618                 if( onode->pkt->pkttype == PKT_USER_ID )
619                     break;
620                 else if( onode->pkt->pkttype == PKT_SIGNATURE
621                          && onode->pkt->pkt.signature->sig_class == 0x20
622                          && node->pkt->pkt.signature->keyid[0]
623                             == onode->pkt->pkt.signature->keyid[0]
624                          && node->pkt->pkt.signature->keyid[1]
625                             == onode->pkt->pkt.signature->keyid[1] ) {
626                     found = 1;
627                     break;
628                 }
629             }
630             if( !found ) {
631                 KBNODE n2 = clone_kbnode(node);
632                 insert_kbnode( keyblock_orig, n2, 0 );
633                 n2->flag |= 1;
634                 node->flag |= 1;
635                 log_info("%s: key %08lX, added revocation certificate\n",
636                                          fname, (ulong)keyid[1]);
637             }
638         }
639     }
640
641     /* 2nd: try to merge new ones in */
642     for(onode=keyblock_orig->next; onode; onode=onode->next ) {
643         if( !(onode->flag & 1) && onode->pkt->pkttype == PKT_USER_ID) {
644             /* find the user id in the imported keyblock */
645             for(node=keyblock->next; node; node=node->next )
646                 if( !(node->flag & 1)
647                     && node->pkt->pkttype == PKT_USER_ID
648                     && !cmp_user_ids( onode->pkt->pkt.user_id,
649                                           node->pkt->pkt.user_id ) )
650                     break;
651             if( node ) { /* found: merge */
652                 rc = merge_sigs( onode, node, n_sigs, fname, keyid );
653                 if( rc )
654                     return rc;
655             }
656         }
657     }
658
659     /* 3rd: add new user-ids */
660     for(node=keyblock->next; node; node=node->next ) {
661         if( !(node->flag & 1) && node->pkt->pkttype == PKT_USER_ID) {
662             /* do we have this in the original keyblock */
663             for(onode=keyblock_orig->next; onode; onode=onode->next )
664                 if( !(onode->flag & 1)
665                     && onode->pkt->pkttype == PKT_USER_ID
666                     && cmp_user_ids( onode->pkt->pkt.user_id,
667                                      node->pkt->pkt.user_id ) )
668                     break;
669             if( !node ) { /* this is a new user id: append */
670                 rc = append_uid( keyblock_orig, node, n_sigs, fname, keyid);
671                 if( rc )
672                     return rc;
673                 ++*n_uids;
674             }
675         }
676     }
677
678     /* 4th: add new subkeys */
679     /* FIXME */
680
681     return 0;
682 }
683
684
685 /****************
686  * append the userid starting with NODE and all signatures to KEYBLOCK.
687  * Mark all new and copied packets by setting flag bit 0.
688  */
689 static int
690 append_uid( KBNODE keyblock, KBNODE node, int *n_sigs,
691                                           const char *fname, u32 *keyid )
692 {
693     KBNODE n;
694
695     assert(node->pkt->pkttype == PKT_USER_ID );
696     /* at lease a self signature comes next to the user-id */
697     if( node->next->pkt->pkttype == PKT_USER_ID ) {
698         log_error("%s: key %08lX, our copy has no self-signature\n",
699                                                   fname, (ulong)keyid[1]);
700         return G10ERR_GENERAL;
701     }
702
703     for( ;node && node->pkt->pkttype != PKT_USER_ID; node = node->next ) {
704         /* we add a clone to the original keyblock, because this
705          * one is released first */
706         n = clone_kbnode(node);
707         add_kbnode( keyblock, n );
708         node->flag |= 1;
709         n->flag |= 1;
710         if( n->pkt->pkttype == PKT_SIGNATURE )
711             ++*n_sigs;
712     }
713
714     return 0;
715 }
716
717
718 /****************
719  * Merge the sigs from SRC onto DST. SRC and DST are both a PKT_USER_ID.
720  * (how should we handle comment packets here?)
721  */
722 static int
723 merge_sigs( KBNODE dst, KBNODE src, int *n_sigs,
724                                     const char *fname, u32 *keyid )
725 {
726     KBNODE n, n2;
727     int found=0;
728
729     assert(dst->pkt->pkttype == PKT_USER_ID );
730     assert(src->pkt->pkttype == PKT_USER_ID );
731     /* at least a self signature comes next to the user-ids */
732     assert(src->next->pkt->pkttype != PKT_USER_ID );
733     if( dst->next->pkt->pkttype == PKT_USER_ID ) {
734         log_error("%s: key %08lX, our copy has no self-signature\n",
735                                                   fname, (ulong)keyid[1]);
736         return 0;
737     }
738
739
740     for(n=src->next; n && n->pkt->pkttype != PKT_USER_ID; n = n->next ) {
741         if( n->pkt->pkttype != PKT_SIGNATURE )
742             continue;
743         found = 0;
744         for(n2=dst->next; n2 && n2->pkt->pkttype != PKT_USER_ID; n2 = n2->next)
745             if( n2->pkt->pkttype == PKT_SIGNATURE
746                 && n->pkt->pkt.signature->keyid[0]
747                    == n2->pkt->pkt.signature->keyid[0]
748                 && n->pkt->pkt.signature->keyid[1]
749                    == n2->pkt->pkt.signature->keyid[1] ) {
750             found++;
751             break;
752         }
753
754         if( found ) { /* we already have this signature */
755             /* Hmmm: should we compare the timestamp etc?
756              * but then we have first to see whether this signature is valid
757              * - or simply add it in such a case and let trustdb logic
758              * decide whether to remove the old one
759              */
760             continue;
761         }
762
763         /* This signature is new, append N to DST it.
764          * We add a clone to the original keyblock, because this
765          * one is released first */
766         n2 = clone_kbnode(n);
767         insert_kbnode( dst, n2, PKT_USER_ID );
768         n2->flag |= 1;
769         n->flag |= 1;
770         ++*n_sigs;
771     }
772
773     return 0;
774 }
775