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