Forgot to commit this:
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002 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 <assert.h>
26
27 #include "errors.h"
28 #include "iobuf.h"
29 #include "keydb.h"
30 #include "memory.h"
31 #include "util.h"
32 #include "options.h"
33 #include "packet.h"
34 #include "main.h"
35 #include "i18n.h"
36 #include "tdbio.h"
37 #include "trustdb.h"
38
39
40 /*
41  * A structure to store key identification as well as some stuff needed
42  * for validation 
43  */
44 struct key_item {
45   struct key_item *next;
46   unsigned int ownertrust;
47   u32 kid[2];
48 };
49
50
51 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
52
53 /*
54  * Structure to keep track of keys, this is used as an array wherre
55  * the item right after the last one has a keyblock set to NULL. 
56  * Maybe we can drop this thing and replace it by key_item
57  */
58 struct key_array {
59   KBNODE keyblock;
60 };
61
62
63 /* control information for the trust DB */
64 static struct {
65     int init;
66     int level;
67     char *dbname;
68 } trustdb_args;
69
70 /* some globals */
71 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
72 static struct key_item *utk_list;      /* all ultimately trusted keys */
73
74 static int pending_check_trustdb;
75
76 static int validate_keys (int interactive);
77
78 \f
79 /**********************************************
80  ************* some helpers *******************
81  **********************************************/
82
83 static struct key_item *
84 new_key_item (void)
85 {
86   struct key_item *k;
87   
88   k = m_alloc_clear (sizeof *k);
89   return k;
90 }
91
92 static void
93 release_key_items (struct key_item *k)
94 {
95   struct key_item *k2;
96
97   for (; k; k = k2)
98     {
99       k2 = k->next;
100       m_free (k);
101     }
102 }
103
104 /*
105  * For fast keylook up we need a hash table.  Each byte of a KeyIDs
106  * should be distributed equally over the 256 possible values (except
107  * for v3 keyIDs but we consider them as not important here). So we
108  * can just use 10 bits to index a table of 1024 key items. 
109  * Possible optimization: Don not use key_items but other hash_table when the
110  * duplicates lists gets too large. 
111  */
112 static KeyHashTable 
113 new_key_hash_table (void)
114 {
115   struct key_item **tbl;
116
117   tbl = m_alloc_clear (1024 * sizeof *tbl);
118   return tbl;
119 }
120
121 static void
122 release_key_hash_table (KeyHashTable tbl)
123 {
124   int i;
125
126   if (!tbl)
127     return;
128   for (i=0; i < 1024; i++)
129     release_key_items (tbl[i]);
130   m_free (tbl);
131 }
132
133 /* 
134  * Returns: True if the keyID is in the given hash table
135  */
136 static int
137 test_key_hash_table (KeyHashTable tbl, u32 *kid)
138 {
139   struct key_item *k;
140
141   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
142     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
143       return 1;
144   return 0;
145 }
146
147 /*
148  * Add a new key to the hash table.  The key is identified by its key ID.
149  */
150 static void
151 add_key_hash_table (KeyHashTable tbl, u32 *kid)
152 {
153   struct key_item *k, *kk;
154
155   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
156     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
157       return; /* already in table */
158   
159   kk = new_key_item ();
160   kk->kid[0] = kid[0];
161   kk->kid[1] = kid[1];
162   kk->next = tbl[(kid[1] & 0x03ff)];
163   tbl[(kid[1] & 0x03ff)] = kk;
164 }
165
166 /*
167  * Release a key_array
168  */
169 static void
170 release_key_array ( struct key_array *keys )
171 {
172     struct key_array *k;
173
174     if (keys) {
175         for (k=keys; k->keyblock; k++)
176             release_kbnode (k->keyblock);
177         m_free (keys);
178     }
179 }
180
181 \f
182 /*********************************************
183  **********  Initialization  *****************
184  *********************************************/
185
186
187
188 /*
189  * Used to register extra ultimately trusted keys - this has to be done
190  * before initializing the validation module.
191  * FIXME: Should be replaced by a function to add those keys to the trustdb.
192  */
193 void
194 register_trusted_key( const char *string )
195 {
196   KEYDB_SEARCH_DESC desc;
197   struct key_item *k;
198
199   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID ) {
200     log_error(_("`%s' is not a valid long keyID\n"), string );
201     return;
202   }
203
204   k = new_key_item ();
205   k->kid[0] = desc.u.kid[0];
206   k->kid[1] = desc.u.kid[1];
207   k->next = user_utk_list;
208   user_utk_list = k;
209 }
210
211 /*
212  * Helper to add a key to the global list of ultimately trusted keys.
213  * Retruns: true = inserted, false = already in in list.
214  */
215 static int
216 add_utk (u32 *kid)
217 {
218   struct key_item *k;
219
220   for (k = utk_list; k; k = k->next) 
221     {
222       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
223         {
224           return 0;
225         }
226     }
227
228   k = new_key_item ();
229   k->kid[0] = kid[0];
230   k->kid[1] = kid[1];
231   k->ownertrust = TRUST_ULTIMATE;
232   k->next = utk_list;
233   utk_list = k;
234   if( opt.verbose > 1 )
235     log_info(_("key %08lX: accepted as trusted key\n"), (ulong)kid[1]);
236   return 1;
237 }
238
239
240 /****************
241  * Verify that all our secret keys are usable and put them into the utk_list.
242  */
243 static void
244 verify_own_keys(void)
245 {
246   TRUSTREC rec;
247   ulong recnum;
248   int rc;
249   struct key_item *k;
250   int hint_shown = 0;
251
252   if (utk_list)
253     return;
254
255   /* scan the trustdb to find all ultimately trusted keys */
256   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
257     {
258       if ( rec.rectype == RECTYPE_TRUST 
259            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
260         {
261             byte *fpr = rec.r.trust.fingerprint;
262             int fprlen;
263             u32 kid[2];
264             
265             /* Problem: We do only use fingerprints in the trustdb but
266              * we need the keyID here to indetify the key; we can only
267              * use that ugly hack to distinguish between 16 and 20
268              * butes fpr - it does not work always so we better change
269              * the whole validation code to only work with
270              * fingerprints */
271             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
272             keyid_from_fingerprint (fpr, fprlen, kid);
273             if (!add_utk (kid))
274                 log_info(_("key %08lX occurs more than once in the trustdb\n"),
275                             (ulong)kid[1]);
276         }
277     }
278   
279   /* the --trusted-key option is again deprecated; however we automagically
280    * add those keys to the trustdb */
281   for (k = user_utk_list; k; k = k->next) 
282     {
283       if ( add_utk (k->kid) ) 
284         { /* not yet in trustDB as ultimately trusted */
285           PKT_public_key pk;
286
287           memset (&pk, 0, sizeof pk);
288           rc = get_pubkey (&pk, k->kid);
289           if (rc) {
290             log_info(_("key %08lX: no public key for trusted key - skipped\n"),
291                      (ulong)k->kid[1] );
292           }
293           else {
294             update_ownertrust (&pk,
295                                ((get_ownertrust (&pk) & ~TRUST_MASK)
296                                 | TRUST_ULTIMATE ));
297             release_public_key_parts (&pk);
298           }
299           if (!hint_shown)
300             {
301               log_info ("the --trusted-key option is now obsolete; "
302                         "use the --edit command instead.\n");
303               log_info ("given keys will be marked as trusted\n");
304               hint_shown = 1;
305             }
306           log_info ("key %08lX marked as ultimately trusted\n",
307                     (ulong)k->kid[1]);
308         }
309     }
310
311
312   /* release the helper table table */
313   release_key_items (user_utk_list);
314   user_utk_list = NULL;
315   return;
316 }
317
318 \f
319 /*********************************************
320  *********** TrustDB stuff *******************
321  *********************************************/
322
323 /*
324  * Read a record but die if it does not exist
325  */
326 static void
327 read_record (ulong recno, TRUSTREC *rec, int rectype )
328 {
329   int rc = tdbio_read_record (recno, rec, rectype);
330   if (rc)
331     {
332       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
333                 recno, rec->rectype, g10_errstr(rc) );
334       tdbio_invalid();
335     }
336   if (rectype != rec->rectype)
337     {
338       log_error(_("trust record %lu is not of requested type %d\n"),
339                 rec->recnum, rectype);
340       tdbio_invalid();
341     }
342 }
343
344 /*
345  * Write a record and die on error
346  */
347 static void
348 write_record (TRUSTREC *rec)
349 {
350   int rc = tdbio_write_record (rec);
351   if (rc)
352     {
353       log_error(_("trust record %lu, type %d: write failed: %s\n"),
354                             rec->recnum, rec->rectype, g10_errstr(rc) );
355       tdbio_invalid();
356     }
357 }
358
359 /*
360  * sync the TrustDb and die on error
361  */
362 static void
363 do_sync(void)
364 {
365     int rc = tdbio_sync ();
366     if(rc)
367       {
368         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
369         g10_exit(2);
370       }
371 }
372
373
374 /****************
375  * Perform some checks over the trustdb
376  *  level 0: only open the db
377  *        1: used for initial program startup
378  */
379 int
380 setup_trustdb( int level, const char *dbname )
381 {
382     /* just store the args */
383     if( trustdb_args.init )
384         return 0;
385     trustdb_args.level = level;
386     trustdb_args.dbname = dbname? m_strdup(dbname): NULL;
387     return 0;
388 }
389
390 void
391 init_trustdb()
392 {
393   int rc=0;
394   int level = trustdb_args.level;
395   const char* dbname = trustdb_args.dbname;
396
397   if( trustdb_args.init )
398     return;
399
400   trustdb_args.init = 1;
401
402   if ( !level || level==1)
403     {
404       rc = tdbio_set_dbname( dbname, !!level );
405       if( !rc )
406         {
407           if( !level )
408             return;
409           
410           /* verify that our own keys are in the trustDB
411            * or move them to the trustdb. */
412           verify_own_keys();
413           
414           /* should we check whether there is no other ultimately trusted
415            * key in the database? */
416         }
417     }
418   else
419     BUG();
420   if( rc )
421     log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
422 }
423
424
425
426 \f
427 /***********************************************
428  *************  Print helpers   ****************
429  ***********************************************/
430
431 /****************
432  * This function returns a letter for a trustvalue  Trust flags
433  * are ignore.
434  */
435 int
436 trust_letter (unsigned int value)
437 {
438   switch( (value & TRUST_MASK) ) 
439     {
440     case TRUST_UNKNOWN:   return '-';
441     case TRUST_EXPIRED:   return 'e';
442     case TRUST_UNDEFINED: return 'q';
443     case TRUST_NEVER:     return 'n';
444     case TRUST_MARGINAL:  return 'm';
445     case TRUST_FULLY:     return 'f';
446     case TRUST_ULTIMATE:  return 'u';
447     default:              return 0;
448     }
449 }
450
451
452 /****************
453  * Recreate the WoT but do not ask for new ownertrusts.  Special
454  * feature: In batch mode and without a forced yes, this is only done
455  * when a check is due.  This can be used to run the check from a crontab
456  */
457 void
458 check_trustdb ()
459 {
460   init_trustdb();
461   if (opt.batch && !opt.answer_yes)
462     {
463       ulong scheduled;
464
465       scheduled = tdbio_read_nextcheck ();
466       if (!scheduled)
467         {
468           log_info (_("no need for a trustdb check\n"));
469           return;
470         }
471
472       if (scheduled > make_timestamp ())
473         {
474           log_info (_("next trustdb check due at %s\n"),
475                     strtimestamp (scheduled));
476           return;
477         }
478     }
479
480   validate_keys (0);
481 }
482
483
484 /*
485  * Recreate the WoT. 
486  */
487 void
488 update_trustdb()
489 {
490   init_trustdb();
491   validate_keys (1);
492 }
493
494 void
495 revalidation_mark (void)
496 {
497   init_trustdb();
498   /* we simply set the time for the next check to 1 (far back in 1970)
499    * so that a --update-trustdb will be scheduled */
500   if (tdbio_write_nextcheck (1))
501       do_sync ();
502   pending_check_trustdb = 1;
503 }
504
505 \f
506 /***********************************************
507  ***********  Ownertrust et al. ****************
508  ***********************************************/
509
510 static int 
511 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
512 {
513   int rc;
514   
515   init_trustdb();
516   rc = tdbio_search_trust_bypk (pk, rec);
517   if (rc == -1)
518     return -1; /* no record yet */
519   if (rc) 
520     {
521       log_error ("trustdb: searching trust record failed: %s\n",
522                  g10_errstr (rc));
523       return rc; 
524     }
525       
526   if (rec->rectype != RECTYPE_TRUST)
527     {
528       log_error ("trustdb: record %lu is not a trust record\n",
529                  rec->recnum);
530       return G10ERR_TRUSTDB; 
531     }      
532   
533   return 0;
534 }
535
536
537 /****************
538  * Return the assigned ownertrust value for the given public key.
539  * The key should be the primary key.
540  */
541 unsigned int 
542 get_ownertrust ( PKT_public_key *pk)
543 {
544   TRUSTREC rec;
545   int rc;
546   
547   rc = read_trust_record (pk, &rec);
548   if (rc == -1)
549     return TRUST_UNKNOWN; /* no record yet */
550   if (rc) 
551     {
552       tdbio_invalid ();
553       return rc; /* actually never reached */
554     }
555   
556   return rec.r.trust.ownertrust;
557 }
558
559 /*
560  * Same as get_ownertrust but return a trust letter instead of an value.
561  */
562 int
563 get_ownertrust_info (PKT_public_key *pk)
564 {
565     unsigned int otrust;
566     int c;
567
568     otrust = get_ownertrust (pk);
569     c = trust_letter( (otrust & TRUST_MASK) );
570     if( !c )
571         c = '?';
572     return c;
573 }
574
575 /*
576  * Set the trust value of the given public key to the new value.
577  * The key should be a primary one.
578  */
579 void
580 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
581 {
582   TRUSTREC rec;
583   int rc;
584   
585   rc = read_trust_record (pk, &rec);
586   if (!rc)
587     {
588       if (DBG_TRUST)
589         log_debug ("update ownertrust from %u to %u\n",
590                    (unsigned int)rec.r.trust.ownertrust, new_trust );
591       if (rec.r.trust.ownertrust != new_trust)
592         {
593           rec.r.trust.ownertrust = new_trust;
594           write_record( &rec );
595           revalidation_mark ();
596           do_sync ();
597         }
598     }
599   else if (rc == -1)
600     { /* no record yet - create a new one */
601       size_t dummy;
602
603       if (DBG_TRUST)
604         log_debug ("insert ownertrust %u\n", new_trust );
605
606       memset (&rec, 0, sizeof rec);
607       rec.recnum = tdbio_new_recnum ();
608       rec.rectype = RECTYPE_TRUST;
609       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
610       rec.r.trust.ownertrust = new_trust;
611       write_record (&rec);
612       revalidation_mark ();
613       do_sync ();
614       rc = 0;
615     }
616   else 
617     {
618       tdbio_invalid ();
619     }
620 }
621
622 /* Clear the ownertrust value.  Return true if a changed actually happend. */
623 int
624 clear_ownertrust (PKT_public_key *pk)
625 {
626   TRUSTREC rec;
627   int rc;
628   
629   rc = read_trust_record (pk, &rec);
630   if (!rc)
631     {
632       if (DBG_TRUST)
633         log_debug ("clearing ownertrust (old value %u)\n",
634                    (unsigned int)rec.r.trust.ownertrust);
635       if (rec.r.trust.ownertrust)
636         {
637           rec.r.trust.ownertrust = 0;
638           write_record( &rec );
639           revalidation_mark ();
640           do_sync ();
641           return 1;
642         }
643     }
644   else if (rc != -1)
645     {
646       tdbio_invalid ();
647     }
648   return 0;
649 }
650
651 /* 
652  * Note: Caller has to do a sync 
653  */
654 static void
655 update_validity (PKT_public_key *pk, const byte *namehash,
656                  int depth, int validity)
657 {
658   TRUSTREC trec, vrec;
659   int rc;
660   ulong recno;
661   
662   rc = read_trust_record (pk, &trec);
663   if (rc && rc != -1)
664     {
665       tdbio_invalid ();
666       return;
667     }
668   if (rc == -1) /* no record yet - create a new one */
669     { 
670       size_t dummy;
671
672       rc = 0;
673       memset (&trec, 0, sizeof trec);
674       trec.recnum = tdbio_new_recnum ();
675       trec.rectype = RECTYPE_TRUST;
676       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
677       trec.r.trust.ownertrust = 0;
678       }
679
680   /* locate an existing one */
681   recno = trec.r.trust.validlist;
682   while (recno)
683     {
684       read_record (recno, &vrec, RECTYPE_VALID);
685       if ( !memcmp (vrec.r.valid.namehash, namehash, 20) )
686         break;
687       recno = vrec.r.valid.next;
688     }
689
690   if (!recno) /* insert a new validity record */
691     {
692       memset (&vrec, 0, sizeof vrec);
693       vrec.recnum = tdbio_new_recnum ();
694       vrec.rectype = RECTYPE_VALID;
695       memcpy (vrec.r.valid.namehash, namehash, 20);
696       vrec.r.valid.next = trec.r.trust.validlist;
697     }
698   vrec.r.valid.validity = validity;
699   write_record (&vrec);
700   trec.r.trust.depth = depth;
701   trec.r.trust.validlist = vrec.recnum;
702   write_record (&trec);
703 }
704
705
706 /* reset validity for all user IDs.  Caller must sync. */
707 static int
708 clear_validity (PKT_public_key *pk)
709 {
710   TRUSTREC trec, vrec;
711   int rc;
712   ulong recno;
713   int any = 0;
714   
715   rc = read_trust_record (pk, &trec);
716   if (rc && rc != -1)
717     {
718       tdbio_invalid ();
719       return 0;
720     }
721   if (rc == -1) /* no record yet - no need to clerar it then ;-) */
722     return 0;
723
724   /* reset validity for all user IDs */
725   recno = trec.r.trust.validlist;
726   while (recno)
727     {
728       read_record (recno, &vrec, RECTYPE_VALID);
729       if ((vrec.r.valid.validity & TRUST_MASK))
730         {
731           vrec.r.valid.validity &= ~TRUST_MASK;
732           write_record (&vrec);
733           any = 1;
734         }
735       recno = vrec.r.valid.next;
736     }
737
738   return any;
739 }
740
741
742 \f
743 /***********************************************
744  *********  Query trustdb values  **************
745  ***********************************************/
746
747 /*
748  * Return the validity information for PK.  If the namehash is not
749  * NULL, the validity of the corresponsing user ID is returned,
750  * otherwise, a reasonable value for the entire key is returned. 
751  */
752 unsigned int
753 get_validity (PKT_public_key *pk, const byte *namehash)
754 {
755   static int did_nextcheck;
756   TRUSTREC trec, vrec;
757   int rc;
758   ulong recno;
759   unsigned int validity;
760   u32 kid[2];
761   PKT_public_key *main_pk;
762   
763   init_trustdb ();
764   if (!did_nextcheck)
765     {
766       ulong scheduled;
767
768       did_nextcheck = 1;
769       scheduled = tdbio_read_nextcheck ();
770       if (scheduled && scheduled <= make_timestamp ())
771         {
772           if (opt.no_auto_check_trustdb) 
773             {
774               pending_check_trustdb = 1;
775               log_info ("please do a --check-trustdb\n");
776             }
777           else
778             {
779               log_info (_("checking the trustdb\n"));
780               validate_keys (0);
781             }
782         }
783     }
784
785   keyid_from_pk (pk, kid);
786   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
787     { /* this is a subkey - get the mainkey */
788       main_pk = m_alloc_clear (sizeof *main_pk);
789       rc = get_pubkey (main_pk, pk->main_keyid);
790       if (rc)
791         {
792           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
793                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
794           validity = TRUST_UNKNOWN; 
795           goto leave;
796         }
797     }
798   else
799     main_pk = pk;
800
801   rc = read_trust_record (main_pk, &trec);
802   if (rc && rc != -1)
803     {
804       tdbio_invalid ();
805       return 0;
806     }
807   if (rc == -1) /* no record found */
808     {
809       validity = TRUST_UNKNOWN; 
810       goto leave;
811     }
812
813   /* loop over all user IDs */
814   recno = trec.r.trust.validlist;
815   validity = 0;
816   while (recno)
817     {
818       read_record (recno, &vrec, RECTYPE_VALID);
819       if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
820         validity = (vrec.r.valid.validity & TRUST_MASK);
821       if ( namehash && !memcmp (vrec.r.valid.namehash, namehash, 20) )
822         break;
823       recno = vrec.r.valid.next;
824     }
825   
826   if (recno) /* okay, use the user ID associated one */
827     validity = (vrec.r.valid.validity & TRUST_MASK);
828
829   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
830     validity |= TRUST_FLAG_DISABLED;
831
832  leave:
833   /* set some flags direct from the key */
834   if (main_pk->is_revoked)
835     validity |= TRUST_FLAG_REVOKED;
836   if (main_pk != pk && pk->is_revoked)
837     validity |= TRUST_FLAG_SUB_REVOKED;
838   /* Note: expiration is a trust value and not a flag - don't know why
839    * I initially designed it that way */
840   if (main_pk->has_expired || pk->has_expired)
841     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
842   
843   if (pending_check_trustdb)
844     validity |= TRUST_FLAG_PENDING_CHECK;
845
846   if (main_pk != pk)
847     free_public_key (main_pk);
848   return validity;
849 }
850
851
852 int
853 get_validity_info (PKT_public_key *pk, const byte *namehash)
854 {
855     int trustlevel;
856     int c;
857
858     trustlevel = get_validity (pk, namehash);
859     if( trustlevel & TRUST_FLAG_DISABLED )
860         return 'd';
861     if( trustlevel & TRUST_FLAG_REVOKED )
862         return 'r';
863     c = trust_letter ( (trustlevel & TRUST_MASK) );
864     if( !c )
865         c = '?';
866     return c;
867 }
868
869
870
871
872 void
873 list_trust_path( const char *username )
874 {
875 }
876
877
878
879
880 /****************
881  * Enumerate all keys, which are needed to build all trust paths for
882  * the given key.  This function does not return the key itself or
883  * the ultimate key (the last point in cerificate chain).  Only
884  * certificate chains which ends up at an ultimately trusted key
885  * are listed.  If ownertrust or validity is not NULL, the corresponding
886  * value for the returned LID is also returned in these variable(s).
887  *
888  *  1) create a void pointer and initialize it to NULL
889  *  2) pass this void pointer by reference to this function.
890  *     Set lid to the key you want to enumerate and pass it by reference.
891  *  3) call this function as long as it does not return -1
892  *     to indicate EOF. LID does contain the next key used to build the web
893  *  4) Always call this function a last time with LID set to NULL,
894  *     so that it can free its context.
895  *
896  * Returns: -1 on EOF or the level of the returned LID
897  */
898 int
899 enum_cert_paths( void **context, ulong *lid,
900                  unsigned *ownertrust, unsigned *validity )
901 {
902     return -1;
903 }
904
905
906 /****************
907  * Print the current path
908  */
909 void
910 enum_cert_paths_print( void **context, FILE *fp,
911                                        int refresh, ulong selected_lid )
912 {
913     return;
914 }
915
916
917 \f
918 /****************************************
919  *********** NEW NEW NEW ****************
920  ****************************************/
921
922 static int
923 ask_ownertrust (u32 *kid)
924 {
925   PKT_public_key *pk;
926   int rc;
927   int ot;
928
929   pk = m_alloc_clear (sizeof *pk);
930   rc = get_pubkey (pk, kid);
931   if (rc)
932     {
933       log_error (_("public key %08lX not found: %s\n"),
934                  (ulong)kid[1], g10_errstr(rc) );
935       return TRUST_UNKNOWN;
936     }
937  
938   ot=edit_ownertrust(pk,0);
939   if(ot>0)
940     ot = get_ownertrust (pk);
941   else if(ot==0)
942     ot = TRUST_UNDEFINED;
943   else
944     ot = -1; /* quit */
945   free_public_key( pk );
946   return ot;
947 }
948
949
950 static void
951 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
952 {
953   for ( ;node; node = node->next )
954     if (node->pkt->pkttype == PKT_PUBLIC_KEY
955         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
956       {
957         u32 aki[2];
958
959         keyid_from_pk (node->pkt->pkt.public_key, aki);
960         add_key_hash_table (tbl, aki);
961       }
962 }
963
964
965
966 static void
967 dump_key_array (int depth, struct key_array *keys)
968 {
969   struct key_array *kar;
970
971   for (kar=keys; kar->keyblock; kar++)
972     {
973       KBNODE node = kar->keyblock;
974       u32 kid[2];
975
976       keyid_from_pk(node->pkt->pkt.public_key, kid);
977       printf ("%d:%08lX%08lX:K::%c::::\n",
978               depth, (ulong)kid[0], (ulong)kid[1], '?');
979
980       for (; node; node = node->next)
981         {
982           if (node->pkt->pkttype == PKT_USER_ID)
983             {
984               int len = node->pkt->pkt.user_id->len;
985
986               if (len > 30)
987                 len = 30;
988               printf ("%d:%08lX%08lX:U:::%c:::",
989                       depth, (ulong)kid[0], (ulong)kid[1],
990                       (node->flag & 4)? 'f':
991                       (node->flag & 2)? 'm':
992                       (node->flag & 1)? 'q':'-');
993               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
994               putchar (':');
995               putchar ('\n');
996             }
997         }
998     }
999 }  
1000
1001
1002 static void
1003 store_validation_status (int depth, KBNODE keyblock)
1004 {
1005   KBNODE node;
1006   byte namehash[20];
1007   int status;
1008   int any = 0;
1009
1010   for (node=keyblock; node; node = node->next)
1011     {
1012       if (node->pkt->pkttype == PKT_USER_ID)
1013         {
1014           PKT_user_id *uid = node->pkt->pkt.user_id;
1015
1016           if (node->flag & 4)
1017             status = TRUST_FULLY;
1018           else if (node->flag & 2)
1019             status = TRUST_MARGINAL;
1020           else if (node->flag & 1)
1021             status = TRUST_UNDEFINED;
1022           else
1023             status = 0;
1024           
1025           if (status)
1026             {
1027               if( uid->attrib_data )
1028                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1029               else
1030                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1031               
1032               update_validity (keyblock->pkt->pkt.public_key,
1033                                namehash, depth, status);
1034               any = 1;
1035             }
1036         }
1037     }
1038
1039   if (any)
1040     do_sync ();
1041 }  
1042
1043 /*
1044  * check whether the signature sig is in the klist k
1045  */
1046 static struct key_item *
1047 is_in_klist (struct key_item *k, PKT_signature *sig)
1048 {
1049   for (; k; k = k->next)
1050     {
1051       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1052         return k;
1053     }
1054   return NULL;
1055 }
1056
1057 /*
1058  * Mark the signature of the given UID which are used to certify it.
1059  * To do this, we first revmove all signatures which are not valid and
1060  * from the remain ones we look for the latest one.  If this is not a
1061  * certification revocation signature we mark the signature by setting
1062  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1063  * purposes.  
1064  */
1065 static void
1066 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1067                        u32 *main_kid, struct key_item *klist,
1068                        u32 curtime, u32 *next_expire)
1069 {
1070   KBNODE node;
1071   PKT_signature *sig;
1072   
1073   /* first check all signatures */
1074   for (node=uidnode->next; node; node = node->next)
1075     {
1076       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1077       if (node->pkt->pkttype == PKT_USER_ID
1078           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1079         break; /* ready */
1080       if (node->pkt->pkttype != PKT_SIGNATURE)
1081         continue;
1082       
1083       sig = node->pkt->pkt.signature;
1084       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1085         continue; /* ignore self-signatures */
1086       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1087         continue; /* we only look at these signature classes */
1088       if (!is_in_klist (klist, sig))
1089         continue;  /* no need to check it then */
1090       if (check_key_signature (keyblock, node, NULL))
1091         continue; /* ignore invalid signatures */
1092       node->flag |= 1<<9;
1093     }      
1094   /* reset the remaining flags */
1095   for (; node; node = node->next)
1096       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1097
1098   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1099    * bit 10 will be set by the loop to keep track of keyIDs already
1100    * processed, bit 8 will be set for the usable signatures */
1101
1102   /* for each cert figure out the latest valid one */
1103   for (node=uidnode->next; node; node = node->next)
1104     {
1105       KBNODE n, signode;
1106       u32 kid[2];
1107       u32 sigdate;
1108       
1109       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1110         break;
1111       if ( !(node->flag & (1<<9)) )
1112         continue; /* not a node to look at */
1113       if ( (node->flag & (1<<10)) )
1114         continue; /* signature with a keyID already processed */
1115       node->flag |= (1<<10); /* mark this node as processed */
1116       sig = node->pkt->pkt.signature;
1117       signode = node;
1118       sigdate = sig->timestamp;
1119       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1120       for (n=uidnode->next; n; n = n->next)
1121         {
1122           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1123             break;
1124           if ( !(n->flag & (1<<9)) )
1125             continue;
1126           if ( (n->flag & (1<<10)) )
1127             continue; /* shortcut already processed signatures */
1128           sig = n->pkt->pkt.signature;
1129           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1130             continue;
1131           n->flag |= (1<<10); /* mark this node as processed */
1132
1133           /* If signode is nonrevocable and unexpired and n isn't,
1134              then take signode (skip).  It doesn't matter which is
1135              older: if signode was older then we don't want to take n
1136              as signode is nonrevocable.  If n was older then we're
1137              automatically fine. */
1138           
1139           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1140                !signode->pkt->pkt.signature->flags.revocable &&
1141                (signode->pkt->pkt.signature->expiredate==0 ||
1142                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1143              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1144                 !n->pkt->pkt.signature->flags.revocable &&
1145                 (n->pkt->pkt.signature->expiredate==0 ||
1146                  n->pkt->pkt.signature->expiredate>curtime))))
1147             continue;
1148
1149           /* If n is nonrevocable and unexpired and signode isn't,
1150              then take n.  Again, it doesn't matter which is older: if
1151              n was older then we don't want to take signode as n is
1152              nonrevocable.  If signode was older then we're
1153              automatically fine. */
1154           
1155           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1156                 !signode->pkt->pkt.signature->flags.revocable &&
1157                 (signode->pkt->pkt.signature->expiredate==0 ||
1158                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1159              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1160                !n->pkt->pkt.signature->flags.revocable &&
1161                (n->pkt->pkt.signature->expiredate==0 ||
1162                 n->pkt->pkt.signature->expiredate>curtime))))
1163             {
1164               signode = n;
1165               sigdate = sig->timestamp;
1166               continue;
1167             }
1168
1169           /* At this point, if it's newer, it goes in as the only
1170              remaining possibilities are signode and n are both either
1171              revocable or expired or both nonrevocable and unexpired.
1172              If the timestamps are equal take the later ordered
1173              packet, presuming that the key packets are hopefully in
1174              their original order. */
1175
1176           if (sig->timestamp >= sigdate)
1177             {
1178               signode = n;
1179               sigdate = sig->timestamp;
1180             }
1181         }
1182       sig = signode->pkt->pkt.signature;
1183       if (IS_UID_SIG (sig))
1184         { /* this seems to be a usable one which is not revoked. 
1185            * Just need to check whether there is an expiration time,
1186            * We do the expired certification after finding a suitable
1187            * certification, the assumption is that a signator does not
1188            * want that after the expiration of his certificate the
1189            * system falls back to an older certification which has a
1190            * different expiration time */
1191           const byte *p;
1192           u32 expire;
1193                     
1194           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1195           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1196
1197           if (expire==0 || expire > curtime )
1198             {
1199               signode->flag |= (1<<8); /* yeah, found a good cert */
1200               if (expire && expire < *next_expire)
1201                 *next_expire = expire;
1202             }
1203         }
1204     }
1205 }
1206
1207
1208 /*
1209  * Return true if the key is signed by one of the keys in the given
1210  * key ID list.  User IDs with a valid signature are marked by node
1211  * flags as follows:
1212  *  flag bit 0: There is at least one signature
1213  *           1: There is marginal confidence that this is a legitimate uid
1214  *           2: There is full confidence that this is a legitimate uid.
1215  *           8: Used for internal purposes.
1216  *           9: Ditto (in mark_usable_uid_certs())
1217  *          10: Ditto (ditto)
1218  * This function assumes that all kbnode flags are cleared on entry.
1219  */
1220 static int
1221 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1222                        u32 curtime, u32 *next_expire)
1223 {
1224   struct key_item *kr;
1225   KBNODE node, uidnode=NULL;
1226   PKT_public_key *pk = kb->pkt->pkt.public_key;
1227   u32 main_kid[2];
1228   int issigned=0, any_signed = 0, fully_count =0, marginal_count = 0;
1229
1230   keyid_from_pk(pk, main_kid);
1231   for (node=kb; node; node = node->next)
1232     {
1233       if (node->pkt->pkttype == PKT_USER_ID)
1234         {
1235           if (uidnode && issigned)
1236             {
1237               if (fully_count >= opt.completes_needed
1238                   || marginal_count >= opt.marginals_needed )
1239                 uidnode->flag |= 4; 
1240               else if (fully_count || marginal_count)
1241                 uidnode->flag |= 2;
1242               uidnode->flag |= 1;
1243               any_signed = 1;
1244             }
1245           uidnode = node;
1246           issigned = 0;
1247           fully_count = marginal_count = 0;
1248           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1249                                  curtime, next_expire);
1250         }
1251       else if (node->pkt->pkttype == PKT_SIGNATURE 
1252                && (node->flag & (1<<8)) )
1253         {
1254           PKT_signature *sig = node->pkt->pkt.signature;
1255           
1256           kr = is_in_klist (klist, sig);
1257           if (kr)
1258             {
1259               if (kr->ownertrust == TRUST_ULTIMATE)
1260                 fully_count = opt.completes_needed;
1261               else if (kr->ownertrust == TRUST_FULLY)
1262                 fully_count++;
1263               else if (kr->ownertrust == TRUST_MARGINAL)
1264                 marginal_count++;
1265               issigned = 1;
1266             }
1267         }
1268     }
1269
1270   if (uidnode && issigned)
1271     {
1272       if (fully_count >= opt.completes_needed
1273                || marginal_count >= opt.marginals_needed )
1274         uidnode->flag |= 4; 
1275       else if (fully_count || marginal_count)
1276         uidnode->flag |= 2;
1277       uidnode->flag |= 1;
1278       any_signed = 1;
1279     }
1280
1281   return any_signed;
1282 }
1283
1284
1285 static int
1286 search_skipfnc (void *opaque, u32 *kid)
1287 {
1288   return test_key_hash_table ((KeyHashTable)opaque, kid);
1289 }
1290
1291
1292 /*
1293  * Scan all keys and return a key_array of all suitable keys from
1294  * kllist.  The caller has to pass keydb handle so that we don't use
1295  * to create our own.  Returns either a key_array or NULL in case of
1296  * an error.  No results found are indicated by an empty array.
1297  * Caller hast to release the returned array.  
1298  */
1299 static struct key_array *
1300 validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
1301                    struct key_item *klist, u32 curtime, u32 *next_expire)
1302 {
1303   KBNODE keyblock = NULL;
1304   struct key_array *keys = NULL;
1305   size_t nkeys, maxkeys;
1306   int rc;
1307   KEYDB_SEARCH_DESC desc;
1308   
1309   maxkeys = 1000;
1310   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1311   nkeys = 0;
1312   
1313   rc = keydb_search_reset (hd);
1314   if (rc)
1315     {
1316       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1317       m_free (keys);
1318       return NULL;
1319     }
1320
1321   memset (&desc, 0, sizeof desc);
1322   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1323   desc.skipfnc = search_skipfnc;
1324   desc.skipfncvalue = visited;
1325   rc = keydb_search (hd, &desc, 1);
1326   if (rc == -1)
1327     {
1328       keys[nkeys].keyblock = NULL;
1329       return keys;
1330     }
1331   if (rc)
1332     {
1333       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1334       m_free (keys);
1335       return NULL;
1336     }
1337   
1338   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1339   do
1340     {
1341       PKT_public_key *pk;
1342         
1343       rc = keydb_get_keyblock (hd, &keyblock);
1344       if (rc) 
1345         {
1346           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1347           m_free (keys);
1348           return NULL;
1349         }
1350       
1351       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1352         {
1353           log_debug ("ooops: invalid pkttype %d encountered\n",
1354                      keyblock->pkt->pkttype);
1355           dump_kbnode (keyblock);
1356           release_kbnode(keyblock);
1357           continue;
1358         }
1359
1360       /* prepare the keyblock for further processing */
1361       merge_keys_and_selfsig (keyblock); 
1362       clear_kbnode_flags (keyblock);
1363       pk = keyblock->pkt->pkt.public_key;
1364       if (pk->has_expired || pk->is_revoked)
1365         {
1366           /* it does not make sense to look further at those keys */
1367           mark_keyblock_seen (visited, keyblock);
1368         }
1369       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1370         {
1371           if (pk->expiredate && pk->expiredate >= curtime
1372               && pk->expiredate < *next_expire)
1373             *next_expire = pk->expiredate;
1374
1375           if (nkeys == maxkeys) {
1376             maxkeys += 1000;
1377             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1378           }
1379           keys[nkeys++].keyblock = keyblock;
1380           /* this key is signed - don't check it again */
1381           mark_keyblock_seen (visited, keyblock);
1382           keyblock = NULL;
1383         }
1384
1385       release_kbnode (keyblock);
1386       keyblock = NULL;
1387     } 
1388   while ( !(rc = keydb_search (hd, &desc, 1)) );
1389   if (rc && rc != -1) 
1390     {
1391       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1392       m_free (keys);
1393       return NULL;
1394     }
1395
1396   keys[nkeys].keyblock = NULL;
1397   return keys;
1398
1399
1400
1401 static void
1402 reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
1403 {
1404   int rc;
1405   KBNODE keyblock = NULL;
1406   KEYDB_SEARCH_DESC desc;
1407   int count = 0, nreset = 0;
1408   
1409   rc = keydb_search_reset (hd);
1410   if (rc)
1411     {
1412       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1413       return;
1414     }
1415
1416   memset (&desc, 0, sizeof desc);
1417   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1418   desc.skipfnc = search_skipfnc;
1419   desc.skipfncvalue = visited;
1420   rc = keydb_search (hd, &desc, 1);
1421   if (rc && rc != -1 )
1422     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1423   else if (!rc)
1424     {
1425       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1426       do
1427         {
1428           rc = keydb_get_keyblock (hd, &keyblock);
1429           if (rc) 
1430             {
1431               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1432               break;
1433             }
1434           count++;
1435
1436           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1437             {
1438               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1439               release_kbnode (keyblock);
1440             } 
1441         }
1442       while ( !(rc = keydb_search (hd, &desc, 1)) );
1443       if (rc && rc != -1) 
1444         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1445     }
1446   if (opt.verbose)
1447     log_info ("%d unconnected keys (%d trust records cleared)\n",
1448               count, nreset);
1449   do_sync ();
1450
1451
1452
1453 /*
1454  * Run the key validation procedure.
1455  *
1456  * This works this way:
1457  * Step 1: Find all ultimately trusted keys (UTK).
1458  *         mark them all as seen and put them into klist.
1459  * Step 2: loop max_cert_times
1460  * Step 3:   if OWNERTRUST of any key in klist is undefined
1461  *             ask user to assign ownertrust
1462  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1463  * Step 5:     if key is revoked or expired
1464  *                mark key as seen
1465  *                continue loop at Step 4
1466  * Step 6:     For each user ID of that key signed by a key in klist
1467  *                Calculate validity by counting trusted signatures.
1468  *                Set validity of user ID
1469  * Step 7:     If any signed user ID was found
1470  *                mark key as seen
1471  *             End Loop
1472  * Step 8:   Build a new klist from all fully trusted keys from step 6
1473  *           End Loop
1474  *         Ready  
1475  *
1476  */
1477 static int
1478 validate_keys (int interactive)
1479 {
1480   int rc = 0;
1481   int quit=0;
1482   struct key_item *klist = NULL;
1483   struct key_item *k;
1484   struct key_array *keys = NULL;
1485   struct key_array *kar;
1486   KEYDB_HANDLE kdb = NULL;
1487   KBNODE node;
1488   int depth;
1489   int key_count;
1490   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1491   KeyHashTable visited;
1492   u32 start_time, next_expire;
1493
1494   start_time = make_timestamp ();
1495   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1496   visited = new_key_hash_table ();
1497   /* Fixme: Instead of always building a UTK list, we could just build it
1498    * here when needed */
1499   if (!utk_list)
1500     {
1501       log_info ("no ultimately trusted keys found\n");
1502       goto leave;
1503     }
1504
1505
1506   /* mark all UTKs as visited and set validity to ultimate */
1507   for (k=utk_list; k; k = k->next)
1508     {
1509       KBNODE keyblock;
1510       PKT_public_key *pk;
1511
1512       keyblock = get_pubkeyblock (k->kid);
1513       if (!keyblock)
1514         {
1515           log_error (_("public key of ultimately"
1516                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1517           continue;
1518         }
1519       mark_keyblock_seen (visited, keyblock);
1520       pk = keyblock->pkt->pkt.public_key;
1521       for (node=keyblock; node; node = node->next)
1522         {
1523           if (node->pkt->pkttype == PKT_USER_ID)
1524             {
1525               byte namehash[20];
1526               PKT_user_id *uid = node->pkt->pkt.user_id;
1527               
1528               if( uid->attrib_data )
1529                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1530               else
1531                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1532               update_validity (pk, namehash, 0, TRUST_ULTIMATE);
1533             }
1534         }
1535       if ( pk->expiredate && pk->expiredate >= start_time
1536            && pk->expiredate < next_expire)
1537         next_expire = pk->expiredate;
1538       
1539       release_kbnode (keyblock);
1540       do_sync ();
1541     }
1542
1543
1544   klist = utk_list;
1545   kdb = keydb_new (0);
1546
1547   for (depth=0; depth < opt.max_cert_depth; depth++)
1548     {
1549       /* See whether we should assign ownertrust values to the keys in
1550          utk_list.  */
1551       ot_unknown = ot_undefined = ot_never = 0;
1552       ot_marginal = ot_full = ot_ultimate = 0;
1553       for (k=klist; k; k = k->next)
1554         {
1555           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1556               k->ownertrust = ask_ownertrust (k->kid);
1557           if (k->ownertrust == -1)
1558             {
1559               quit=1;
1560               goto leave;
1561             }
1562           else if (k->ownertrust == TRUST_UNKNOWN)
1563             ot_unknown++;
1564           else if (k->ownertrust == TRUST_UNDEFINED)
1565             ot_undefined++;
1566           else if (k->ownertrust == TRUST_NEVER)
1567             ot_never++;
1568           else if (k->ownertrust == TRUST_MARGINAL)
1569             ot_marginal++;
1570           else if (k->ownertrust == TRUST_FULLY)
1571             ot_full++;
1572           else if (k->ownertrust == TRUST_ULTIMATE)
1573             ot_ultimate++;
1574         }
1575
1576       /* Find all keys which are signed by a key in kdlist */
1577       keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
1578       if (!keys) 
1579         {
1580           log_error ("validate_key_list failed\n");
1581           rc = G10ERR_GENERAL;
1582           goto leave;
1583         }
1584
1585
1586       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1587         ;
1588
1589       /* Store the calculated valididation status somewhere */
1590       if (opt.verbose > 1)
1591         dump_key_array (depth, keys);
1592
1593       log_info (_("checking at depth %d signed=%d"
1594                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1595                 depth, key_count, ot_unknown, ot_undefined,
1596                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1597
1598       for (kar=keys; kar->keyblock; kar++)
1599           store_validation_status (depth, kar->keyblock);
1600
1601       /* Build a new kdlist from all fully valid keys in KEYS */
1602       if (klist != utk_list)
1603         release_key_items (klist);
1604       klist = NULL;
1605       for (kar=keys; kar->keyblock; kar++)
1606         {
1607           for (node=kar->keyblock; node; node = node->next)
1608             {
1609               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1610                 {
1611                   k = new_key_item ();
1612                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, k->kid);
1613                   k->ownertrust = get_ownertrust (kar->keyblock
1614                                                   ->pkt->pkt.public_key);
1615                   k->next = klist;
1616                   klist = k;
1617                   break;
1618                 }
1619             }
1620         }
1621       release_key_array (keys);
1622       keys = NULL;
1623       if (!klist)
1624         break; /* no need to dive in deeper */
1625     }
1626
1627   reset_unconnected_keys (kdb, visited);
1628
1629  leave:
1630   keydb_release (kdb);
1631   release_key_array (keys);
1632   release_key_items (klist);
1633   release_key_hash_table (visited);
1634   if (!rc && !quit) /* mark trustDB as checked */
1635     {
1636       if (next_expire == 0xffffffff || next_expire < start_time )
1637         tdbio_write_nextcheck (0); 
1638       else
1639         {
1640           tdbio_write_nextcheck (next_expire); 
1641           log_info (_("next trustdb check due at %s\n"),
1642                     strtimestamp (next_expire));
1643         }
1644       do_sync ();
1645       pending_check_trustdb = 0;
1646     }
1647   return rc;
1648 }
1649
1650