* trustdb.h, trustdb.c (clean_subkeys_from_key): New. Walk through
[gnupg.git] / g10 / trustdb.c
1 /* trustdb.c
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #ifndef DISABLE_REGEX
29 #include <sys/types.h>
30 #ifdef USE_GNU_REGEX
31 #include "_regex.h"
32 #else
33 #include <regex.h>
34 #endif
35 #endif /* !DISABLE_REGEX */
36
37 #include "errors.h"
38 #include "iobuf.h"
39 #include "keydb.h"
40 #include "memory.h"
41 #include "util.h"
42 #include "options.h"
43 #include "packet.h"
44 #include "main.h"
45 #include "i18n.h"
46 #include "tdbio.h"
47 #include "trustdb.h"
48
49
50 /*
51  * A structure to store key identification as well as some stuff needed
52  * for validation 
53  */
54 struct key_item {
55   struct key_item *next;
56   unsigned int ownertrust,min_ownertrust;
57   byte trust_depth;
58   byte trust_value;
59   char *trust_regexp;
60   u32 kid[2];
61 };
62
63
64 typedef struct key_item **KeyHashTable; /* see new_key_hash_table() */
65
66 /*
67  * Structure to keep track of keys, this is used as an array wherre
68  * the item right after the last one has a keyblock set to NULL. 
69  * Maybe we can drop this thing and replace it by key_item
70  */
71 struct key_array {
72   KBNODE keyblock;
73 };
74
75
76 /* control information for the trust DB */
77 static struct {
78     int init;
79     int level;
80     char *dbname;
81 } trustdb_args;
82
83 /* some globals */
84 static struct key_item *user_utk_list; /* temp. used to store --trusted-keys */
85 static struct key_item *utk_list;      /* all ultimately trusted keys */
86
87 static int pending_check_trustdb;
88
89 static int validate_keys (int interactive);
90
91 \f
92 /**********************************************
93  ************* some helpers *******************
94  **********************************************/
95
96 static struct key_item *
97 new_key_item (void)
98 {
99   struct key_item *k;
100   
101   k = m_alloc_clear (sizeof *k);
102   return k;
103 }
104
105 static void
106 release_key_items (struct key_item *k)
107 {
108   struct key_item *k2;
109
110   for (; k; k = k2)
111     {
112       k2 = k->next;
113       m_free (k->trust_regexp);
114       m_free (k);
115     }
116 }
117
118 /*
119  * For fast keylook up we need a hash table.  Each byte of a KeyIDs
120  * should be distributed equally over the 256 possible values (except
121  * for v3 keyIDs but we consider them as not important here). So we
122  * can just use 10 bits to index a table of 1024 key items. 
123  * Possible optimization: Don not use key_items but other hash_table when the
124  * duplicates lists gets too large. 
125  */
126 static KeyHashTable 
127 new_key_hash_table (void)
128 {
129   struct key_item **tbl;
130
131   tbl = m_alloc_clear (1024 * sizeof *tbl);
132   return tbl;
133 }
134
135 static void
136 release_key_hash_table (KeyHashTable tbl)
137 {
138   int i;
139
140   if (!tbl)
141     return;
142   for (i=0; i < 1024; i++)
143     release_key_items (tbl[i]);
144   m_free (tbl);
145 }
146
147 /* 
148  * Returns: True if the keyID is in the given hash table
149  */
150 static int
151 test_key_hash_table (KeyHashTable tbl, u32 *kid)
152 {
153   struct key_item *k;
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 1;
158   return 0;
159 }
160
161 /*
162  * Add a new key to the hash table.  The key is identified by its key ID.
163  */
164 static void
165 add_key_hash_table (KeyHashTable tbl, u32 *kid)
166 {
167   struct key_item *k, *kk;
168
169   for (k = tbl[(kid[1] & 0x03ff)]; k; k = k->next)
170     if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
171       return; /* already in table */
172   
173   kk = new_key_item ();
174   kk->kid[0] = kid[0];
175   kk->kid[1] = kid[1];
176   kk->next = tbl[(kid[1] & 0x03ff)];
177   tbl[(kid[1] & 0x03ff)] = kk;
178 }
179
180 /*
181  * Release a key_array
182  */
183 static void
184 release_key_array ( struct key_array *keys )
185 {
186     struct key_array *k;
187
188     if (keys) {
189         for (k=keys; k->keyblock; k++)
190             release_kbnode (k->keyblock);
191         m_free (keys);
192     }
193 }
194
195 \f
196 /*********************************************
197  **********  Initialization  *****************
198  *********************************************/
199
200
201
202 /*
203  * Used to register extra ultimately trusted keys - this has to be done
204  * before initializing the validation module.
205  * FIXME: Should be replaced by a function to add those keys to the trustdb.
206  */
207 void
208 register_trusted_keyid(u32 *keyid)
209 {
210   struct key_item *k;
211
212   k = new_key_item ();
213   k->kid[0] = keyid[0];
214   k->kid[1] = keyid[1];
215   k->next = user_utk_list;
216   user_utk_list = k;
217 }
218
219 void
220 register_trusted_key( const char *string )
221 {
222   KEYDB_SEARCH_DESC desc;
223
224   if (classify_user_id (string, &desc) != KEYDB_SEARCH_MODE_LONG_KID )
225     {
226       log_error(_("`%s' is not a valid long keyID\n"), string );
227       return;
228     }
229
230   register_trusted_keyid(desc.u.kid);
231 }
232
233 /*
234  * Helper to add a key to the global list of ultimately trusted keys.
235  * Retruns: true = inserted, false = already in in list.
236  */
237 static int
238 add_utk (u32 *kid)
239 {
240   struct key_item *k;
241
242   for (k = utk_list; k; k = k->next) 
243     {
244       if (k->kid[0] == kid[0] && k->kid[1] == kid[1])
245         {
246           return 0;
247         }
248     }
249
250   k = new_key_item ();
251   k->kid[0] = kid[0];
252   k->kid[1] = kid[1];
253   k->ownertrust = TRUST_ULTIMATE;
254   k->next = utk_list;
255   utk_list = k;
256   if( opt.verbose > 1 )
257     log_info(_("key %s: accepted as trusted key\n"), keystr(kid));
258   return 1;
259 }
260
261
262 /****************
263  * Verify that all our secret keys are usable and put them into the utk_list.
264  */
265 static void
266 verify_own_keys(void)
267 {
268   TRUSTREC rec;
269   ulong recnum;
270   int rc;
271   struct key_item *k;
272
273   if (utk_list)
274     return;
275
276   /* scan the trustdb to find all ultimately trusted keys */
277   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
278     {
279       if ( rec.rectype == RECTYPE_TRUST 
280            && (rec.r.trust.ownertrust & TRUST_MASK) == TRUST_ULTIMATE)
281         {
282             byte *fpr = rec.r.trust.fingerprint;
283             int fprlen;
284             u32 kid[2];
285             
286             /* Problem: We do only use fingerprints in the trustdb but
287              * we need the keyID here to indetify the key; we can only
288              * use that ugly hack to distinguish between 16 and 20
289              * butes fpr - it does not work always so we better change
290              * the whole validation code to only work with
291              * fingerprints */
292             fprlen = (!fpr[16] && !fpr[17] && !fpr[18] && !fpr[19])? 16:20;
293             keyid_from_fingerprint (fpr, fprlen, kid);
294             if (!add_utk (kid))
295               log_info(_("key %s occurs more than once in the trustdb\n"),
296                        keystr(kid));
297         }
298     }
299
300   /* Put any --trusted-key keys into the trustdb */
301   for (k = user_utk_list; k; k = k->next) 
302     {
303       if ( add_utk (k->kid) ) 
304         { /* not yet in trustDB as ultimately trusted */
305           PKT_public_key pk;
306
307           memset (&pk, 0, sizeof pk);
308           rc = get_pubkey (&pk, k->kid);
309           if (rc)
310             log_info(_("key %s: no public key for trusted key - skipped\n"),
311                      keystr(k->kid));
312           else
313             {
314               update_ownertrust (&pk,
315                                  ((get_ownertrust (&pk) & ~TRUST_MASK)
316                                   | TRUST_ULTIMATE ));
317               release_public_key_parts (&pk);
318             }
319
320           log_info (_("key %s marked as ultimately trusted\n"),keystr(k->kid));
321         }
322     }
323
324   /* release the helper table table */
325   release_key_items (user_utk_list);
326   user_utk_list = NULL;
327   return;
328 }
329
330 \f
331 /*********************************************
332  *********** TrustDB stuff *******************
333  *********************************************/
334
335 /*
336  * Read a record but die if it does not exist
337  */
338 static void
339 read_record (ulong recno, TRUSTREC *rec, int rectype )
340 {
341   int rc = tdbio_read_record (recno, rec, rectype);
342   if (rc)
343     {
344       log_error(_("trust record %lu, req type %d: read failed: %s\n"),
345                 recno, rec->rectype, g10_errstr(rc) );
346       tdbio_invalid();
347     }
348   if (rectype != rec->rectype)
349     {
350       log_error(_("trust record %lu is not of requested type %d\n"),
351                 rec->recnum, rectype);
352       tdbio_invalid();
353     }
354 }
355
356 /*
357  * Write a record and die on error
358  */
359 static void
360 write_record (TRUSTREC *rec)
361 {
362   int rc = tdbio_write_record (rec);
363   if (rc)
364     {
365       log_error(_("trust record %lu, type %d: write failed: %s\n"),
366                             rec->recnum, rec->rectype, g10_errstr(rc) );
367       tdbio_invalid();
368     }
369 }
370
371 /*
372  * sync the TrustDb and die on error
373  */
374 static void
375 do_sync(void)
376 {
377     int rc = tdbio_sync ();
378     if(rc)
379       {
380         log_error (_("trustdb: sync failed: %s\n"), g10_errstr(rc) );
381         g10_exit(2);
382       }
383 }
384
385 static const char *
386 trust_model_string(void)
387 {
388   switch(opt.trust_model)
389     {
390     case TM_CLASSIC:  return "classic";
391     case TM_PGP:      return "PGP";
392     case TM_EXTERNAL: return "external";
393     case TM_ALWAYS:   return "always";
394     case TM_DIRECT:   return "direct";
395     default:          return "unknown";
396     }
397 }
398
399 /****************
400  * Perform some checks over the trustdb
401  *  level 0: only open the db
402  *        1: used for initial program startup
403  */
404 int
405 setup_trustdb( int level, const char *dbname )
406 {
407     /* just store the args */
408     if( trustdb_args.init )
409         return 0;
410     trustdb_args.level = level;
411     trustdb_args.dbname = dbname? m_strdup(dbname): NULL;
412     return 0;
413 }
414
415 void
416 init_trustdb()
417 {
418   int level = trustdb_args.level;
419   const char* dbname = trustdb_args.dbname;
420
421   if( trustdb_args.init )
422     return;
423
424   trustdb_args.init = 1;
425
426   if(level==0 || level==1)
427     {
428       int rc = tdbio_set_dbname( dbname, !!level );
429       if( rc )
430         log_fatal("can't init trustdb: %s\n", g10_errstr(rc) );
431     }
432   else
433     BUG();
434
435   if(opt.trust_model==TM_AUTO)
436     {
437       /* Try and set the trust model off of whatever the trustdb says
438          it is. */
439       opt.trust_model=tdbio_read_model();
440
441       /* Sanity check this ;) */
442       if(opt.trust_model!=TM_CLASSIC
443          && opt.trust_model!=TM_PGP
444          && opt.trust_model!=TM_EXTERNAL)
445         {
446           log_info(_("unable to use unknown trust model (%d) - "
447                      "assuming %s trust model\n"),opt.trust_model,"PGP");
448           opt.trust_model=TM_PGP;
449         }
450
451       if(opt.verbose)
452         log_info(_("using %s trust model\n"),trust_model_string());
453     }
454
455   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
456     {
457       /* Verify the list of ultimately trusted keys and move the
458          --trusted-keys list there as well. */
459       if(level==1)
460         verify_own_keys();
461
462       if(!tdbio_db_matches_options())
463         pending_check_trustdb=1;
464     }
465 }
466
467
468 /***********************************************
469  *************  Print helpers   ****************
470  ***********************************************/
471
472 /****************
473  * This function returns a letter for a trustvalue  Trust flags
474  * are ignore.
475  */
476 static int
477 trust_letter (unsigned int value)
478 {
479   switch( (value & TRUST_MASK) ) 
480     {
481     case TRUST_UNKNOWN:   return '-';
482     case TRUST_EXPIRED:   return 'e';
483     case TRUST_UNDEFINED: return 'q';
484     case TRUST_NEVER:     return 'n';
485     case TRUST_MARGINAL:  return 'm';
486     case TRUST_FULLY:     return 'f';
487     case TRUST_ULTIMATE:  return 'u';
488     default:              return '?';
489     }
490 }
491
492 /* NOTE TO TRANSLATOR: these strings are similar to those in
493    trust_value_to_string(), but are a fixed length.  This is needed to
494    make attractive information listings where columns line up
495    properly.  The value "10" should be the length of the strings you
496    choose to translate to.  This is the length in printable columns.
497    It gets passed to atoi() so everything after the number is
498    essentially a comment and need not be translated.  Either key and
499    uid are both NULL, or neither are NULL. */
500 const char *
501 uid_trust_string_fixed(PKT_public_key *key,PKT_user_id *uid)
502 {
503   if(!key && !uid)
504     return _("10 translator see trustdb.c:uid_trust_string_fixed");
505   else if(uid->is_revoked || (key && key->is_revoked))
506     return                         _("[ revoked]");
507   else if(uid->is_expired)
508     return                         _("[ expired]");
509   else if(key)
510     switch(get_validity(key,uid)&TRUST_MASK)
511       {
512       case TRUST_UNKNOWN:   return _("[ unknown]");
513       case TRUST_EXPIRED:   return _("[ expired]");
514       case TRUST_UNDEFINED: return _("[  undef ]");
515       case TRUST_MARGINAL:  return _("[marginal]");
516       case TRUST_FULLY:     return _("[  full  ]");
517       case TRUST_ULTIMATE:  return _("[ultimate]");
518       }
519
520   return "err";
521 }
522
523 /* The strings here are similar to those in
524    pkclist.c:do_edit_ownertrust() */
525 const char *
526 trust_value_to_string (unsigned int value)
527 {
528   switch( (value & TRUST_MASK) ) 
529     {
530     case TRUST_UNKNOWN:   return _("unknown");
531     case TRUST_EXPIRED:   return _("expired");
532     case TRUST_UNDEFINED: return _("undefined");
533     case TRUST_NEVER:     return _("never");
534     case TRUST_MARGINAL:  return _("marginal");
535     case TRUST_FULLY:     return _("full");
536     case TRUST_ULTIMATE:  return _("ultimate");
537     default:              return "err";
538     }
539 }
540
541 int
542 string_to_trust_value (const char *str)
543 {
544   if(ascii_strcasecmp(str,"undefined")==0)
545     return TRUST_UNDEFINED;
546   else if(ascii_strcasecmp(str,"never")==0)
547     return TRUST_NEVER;
548   else if(ascii_strcasecmp(str,"marginal")==0)
549     return TRUST_MARGINAL;
550   else if(ascii_strcasecmp(str,"full")==0)
551     return TRUST_FULLY;
552   else if(ascii_strcasecmp(str,"ultimate")==0)
553     return TRUST_ULTIMATE;
554   else
555     return -1;
556 }
557
558 /****************
559  * Recreate the WoT but do not ask for new ownertrusts.  Special
560  * feature: In batch mode and without a forced yes, this is only done
561  * when a check is due.  This can be used to run the check from a crontab
562  */
563 void
564 check_trustdb ()
565 {
566   init_trustdb();
567   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
568     {
569       if (opt.batch && !opt.answer_yes)
570         {
571           ulong scheduled;
572
573           scheduled = tdbio_read_nextcheck ();
574           if (!scheduled)
575             {
576               log_info (_("no need for a trustdb check\n"));
577               return;
578             }
579
580           if (scheduled > make_timestamp ())
581             {
582               log_info (_("next trustdb check due at %s\n"),
583                         strtimestamp (scheduled));
584               return;
585             }
586         }
587
588       validate_keys (0);
589     }
590   else
591     log_info (_("no need for a trustdb check with `%s' trust model\n"),
592               trust_model_string());
593 }
594
595
596 /*
597  * Recreate the WoT. 
598  */
599 void
600 update_trustdb()
601 {
602   init_trustdb();
603   if(opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC)
604     validate_keys (1);
605   else
606     log_info (_("no need for a trustdb update with `%s' trust model\n"),
607               trust_model_string());
608 }
609
610 void
611 revalidation_mark (void)
612 {
613   init_trustdb();
614   /* we simply set the time for the next check to 1 (far back in 1970)
615    * so that a --update-trustdb will be scheduled */
616   if (tdbio_write_nextcheck (1))
617       do_sync ();
618   pending_check_trustdb = 1;
619 }
620
621 int
622 trustdb_pending_check(void)
623 {
624   return pending_check_trustdb;
625 }
626
627 /* If the trustdb is dirty, and we're interactive, update it.
628    Otherwise, check it unless no-auto-check-trustdb is set. */
629 void
630 trustdb_check_or_update(void)
631 {
632   if(trustdb_pending_check())
633     {
634       if(opt.interactive)
635         update_trustdb();
636       else if(!opt.no_auto_check_trustdb)
637         check_trustdb();
638     }
639 }
640
641 void
642 read_trust_options(byte *trust_model,ulong *created,ulong *nextcheck,
643                    byte *marginals,byte *completes,byte *cert_depth)
644 {
645   TRUSTREC opts;
646
647   init_trustdb();
648
649   read_record(0,&opts,RECTYPE_VER);
650
651   if(trust_model)
652     *trust_model=opts.r.ver.trust_model;
653   if(created)
654     *created=opts.r.ver.created;
655   if(nextcheck)
656     *nextcheck=opts.r.ver.nextcheck;
657   if(marginals)
658     *marginals=opts.r.ver.marginals;
659   if(completes)
660     *completes=opts.r.ver.completes;
661   if(cert_depth)
662     *cert_depth=opts.r.ver.cert_depth;
663 }
664
665 /***********************************************
666  ***********  Ownertrust et al. ****************
667  ***********************************************/
668
669 static int 
670 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
671 {
672   int rc;
673   
674   init_trustdb();
675   rc = tdbio_search_trust_bypk (pk, rec);
676   if (rc == -1)
677     return -1; /* no record yet */
678   if (rc) 
679     {
680       log_error ("trustdb: searching trust record failed: %s\n",
681                  g10_errstr (rc));
682       return rc; 
683     }
684       
685   if (rec->rectype != RECTYPE_TRUST)
686     {
687       log_error ("trustdb: record %lu is not a trust record\n",
688                  rec->recnum);
689       return G10ERR_TRUSTDB; 
690     }      
691   
692   return 0;
693 }
694
695 /****************
696  * Return the assigned ownertrust value for the given public key.
697  * The key should be the primary key.
698  */
699 unsigned int 
700 get_ownertrust ( PKT_public_key *pk)
701 {
702   TRUSTREC rec;
703   int rc;
704   
705   rc = read_trust_record (pk, &rec);
706   if (rc == -1)
707     return TRUST_UNKNOWN; /* no record yet */
708   if (rc) 
709     {
710       tdbio_invalid ();
711       return rc; /* actually never reached */
712     }
713
714   return rec.r.trust.ownertrust;
715 }
716
717 unsigned int 
718 get_min_ownertrust (PKT_public_key *pk)
719 {
720   TRUSTREC rec;
721   int rc;
722   
723   rc = read_trust_record (pk, &rec);
724   if (rc == -1)
725     return TRUST_UNKNOWN; /* no record yet */
726   if (rc) 
727     {
728       tdbio_invalid ();
729       return rc; /* actually never reached */
730     }
731
732   return rec.r.trust.min_ownertrust;
733 }
734
735 /*
736  * Same as get_ownertrust but this takes the minimum ownertrust value
737  * into into account, and will bump up the value as needed.
738  */
739 static int
740 get_ownertrust_with_min (PKT_public_key *pk)
741 {
742   unsigned int otrust,otrust_min;
743
744   otrust = (get_ownertrust (pk) & TRUST_MASK);
745   otrust_min = get_min_ownertrust (pk);
746   if(otrust<otrust_min)
747     {
748       /* If the trust that the user has set is less than the trust
749          that was calculated from a trust signature chain, use the
750          higher of the two.  We do this here and not in
751          get_ownertrust since the underlying ownertrust should not
752          really be set - just the appearance of the ownertrust. */
753
754       otrust=otrust_min;
755     }
756
757   return otrust;
758 }
759
760 /*
761  * Same as get_ownertrust but return a trust letter instead of an
762  * value.  This takes the minimum ownertrust value into account.
763  */
764 int
765 get_ownertrust_info (PKT_public_key *pk)
766 {
767   return trust_letter(get_ownertrust_with_min(pk));
768 }
769
770 /*
771  * Same as get_ownertrust but return a trust string instead of an
772  * value.  This takes the minimum ownertrust value into account.
773  */
774 const char *
775 get_ownertrust_string (PKT_public_key *pk)
776 {
777   return trust_value_to_string(get_ownertrust_with_min(pk));
778 }
779
780 /*
781  * Set the trust value of the given public key to the new value.
782  * The key should be a primary one.
783  */
784 void
785 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
786 {
787   TRUSTREC rec;
788   int rc;
789   
790   rc = read_trust_record (pk, &rec);
791   if (!rc)
792     {
793       if (DBG_TRUST)
794         log_debug ("update ownertrust from %u to %u\n",
795                    (unsigned int)rec.r.trust.ownertrust, new_trust );
796       if (rec.r.trust.ownertrust != new_trust)
797         {
798           rec.r.trust.ownertrust = new_trust;
799           write_record( &rec );
800           revalidation_mark ();
801           do_sync ();
802         }
803     }
804   else if (rc == -1)
805     { /* no record yet - create a new one */
806       size_t dummy;
807
808       if (DBG_TRUST)
809         log_debug ("insert ownertrust %u\n", new_trust );
810
811       memset (&rec, 0, sizeof rec);
812       rec.recnum = tdbio_new_recnum ();
813       rec.rectype = RECTYPE_TRUST;
814       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
815       rec.r.trust.ownertrust = new_trust;
816       write_record (&rec);
817       revalidation_mark ();
818       do_sync ();
819       rc = 0;
820     }
821   else 
822     {
823       tdbio_invalid ();
824     }
825 }
826
827 static void
828 update_min_ownertrust (u32 *kid, unsigned int new_trust )
829 {
830   PKT_public_key *pk;
831   TRUSTREC rec;
832   int rc;
833
834   pk = m_alloc_clear (sizeof *pk);
835   rc = get_pubkey (pk, kid);
836   if (rc)
837     {
838       log_error(_("public key %s not found: %s\n"),keystr(kid),g10_errstr(rc));
839       return;
840     }
841
842   rc = read_trust_record (pk, &rec);
843   if (!rc)
844     {
845       if (DBG_TRUST)
846         log_debug ("key %08lX%08lX: update min_ownertrust from %u to %u\n",
847                    (ulong)kid[0],(ulong)kid[1],
848                    (unsigned int)rec.r.trust.min_ownertrust,
849                    new_trust );
850       if (rec.r.trust.min_ownertrust != new_trust)
851         {
852           rec.r.trust.min_ownertrust = new_trust;
853           write_record( &rec );
854           revalidation_mark ();
855           do_sync ();
856         }
857     }
858   else if (rc == -1)
859     { /* no record yet - create a new one */
860       size_t dummy;
861
862       if (DBG_TRUST)
863         log_debug ("insert min_ownertrust %u\n", new_trust );
864
865       memset (&rec, 0, sizeof rec);
866       rec.recnum = tdbio_new_recnum ();
867       rec.rectype = RECTYPE_TRUST;
868       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
869       rec.r.trust.min_ownertrust = new_trust;
870       write_record (&rec);
871       revalidation_mark ();
872       do_sync ();
873       rc = 0;
874     }
875   else 
876     {
877       tdbio_invalid ();
878     }
879 }
880
881 /* Clear the ownertrust and min_ownertrust values.  Return true if a
882    change actually happened. */
883 int
884 clear_ownertrusts (PKT_public_key *pk)
885 {
886   TRUSTREC rec;
887   int rc;
888   
889   rc = read_trust_record (pk, &rec);
890   if (!rc)
891     {
892       if (DBG_TRUST)
893         {
894           log_debug ("clearing ownertrust (old value %u)\n",
895                      (unsigned int)rec.r.trust.ownertrust);
896           log_debug ("clearing min_ownertrust (old value %u)\n",
897                      (unsigned int)rec.r.trust.min_ownertrust);
898         }
899       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
900         {
901           rec.r.trust.ownertrust = 0;
902           rec.r.trust.min_ownertrust = 0;
903           write_record( &rec );
904           revalidation_mark ();
905           do_sync ();
906           return 1;
907         }
908     }
909   else if (rc != -1)
910     {
911       tdbio_invalid ();
912     }
913   return 0;
914 }
915
916 /* 
917  * Note: Caller has to do a sync 
918  */
919 static void
920 update_validity (PKT_public_key *pk, PKT_user_id *uid,
921                  int depth, int validity)
922 {
923   TRUSTREC trec, vrec;
924   int rc;
925   ulong recno;
926
927   namehash_from_uid(uid);
928
929   rc = read_trust_record (pk, &trec);
930   if (rc && rc != -1)
931     {
932       tdbio_invalid ();
933       return;
934     }
935   if (rc == -1) /* no record yet - create a new one */
936     { 
937       size_t dummy;
938
939       rc = 0;
940       memset (&trec, 0, sizeof trec);
941       trec.recnum = tdbio_new_recnum ();
942       trec.rectype = RECTYPE_TRUST;
943       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
944       trec.r.trust.ownertrust = 0;
945       }
946
947   /* locate an existing one */
948   recno = trec.r.trust.validlist;
949   while (recno)
950     {
951       read_record (recno, &vrec, RECTYPE_VALID);
952       if ( !memcmp (vrec.r.valid.namehash, uid->namehash, 20) )
953         break;
954       recno = vrec.r.valid.next;
955     }
956
957   if (!recno) /* insert a new validity record */
958     {
959       memset (&vrec, 0, sizeof vrec);
960       vrec.recnum = tdbio_new_recnum ();
961       vrec.rectype = RECTYPE_VALID;
962       memcpy (vrec.r.valid.namehash, uid->namehash, 20);
963       vrec.r.valid.next = trec.r.trust.validlist;
964       trec.r.trust.validlist = vrec.recnum;
965     }
966   vrec.r.valid.validity = validity;
967   vrec.r.valid.full_count = uid->help_full_count;
968   vrec.r.valid.marginal_count = uid->help_marginal_count;
969   write_record (&vrec);
970   trec.r.trust.depth = depth;
971   write_record (&trec);
972 }
973
974
975 /***********************************************
976  *********  Query trustdb values  **************
977  ***********************************************/
978
979 /* Return true if key is disabled */
980 int
981 cache_disabled_value(PKT_public_key *pk)
982 {
983   int rc;
984   TRUSTREC trec;
985   int disabled=0;
986
987   if(pk->is_disabled)
988     return (pk->is_disabled==2);
989
990   init_trustdb();
991
992   rc = read_trust_record (pk, &trec);
993   if (rc && rc != -1)
994     {
995       tdbio_invalid ();
996       goto leave;
997     }
998   if (rc == -1) /* no record found, so assume not disabled */
999     goto leave;
1000  
1001   if(trec.r.trust.ownertrust & TRUST_FLAG_DISABLED)
1002     disabled=1;
1003  
1004   /* Cache it for later so we don't need to look at the trustdb every
1005      time */
1006   if(disabled)
1007     pk->is_disabled=2;
1008   else
1009     pk->is_disabled=1;
1010
1011  leave:
1012    return disabled;
1013 }
1014
1015 void
1016 check_trustdb_stale(void)
1017 {
1018   static int did_nextcheck=0;
1019
1020   init_trustdb ();
1021   if (!did_nextcheck
1022       && (opt.trust_model==TM_PGP || opt.trust_model==TM_CLASSIC))
1023     {
1024       ulong scheduled;
1025
1026       did_nextcheck = 1;
1027       scheduled = tdbio_read_nextcheck ();
1028       if (scheduled && scheduled <= make_timestamp ())
1029         {
1030           if (opt.no_auto_check_trustdb) 
1031             {
1032               pending_check_trustdb = 1;
1033               log_info (_("please do a --check-trustdb\n"));
1034             }
1035           else
1036             {
1037               log_info (_("checking the trustdb\n"));
1038               validate_keys (0);
1039             }
1040         }
1041     }
1042 }
1043
1044 /*
1045  * Return the validity information for PK.  If the namehash is not
1046  * NULL, the validity of the corresponsing user ID is returned,
1047  * otherwise, a reasonable value for the entire key is returned. 
1048  */
1049 unsigned int
1050 get_validity (PKT_public_key *pk, PKT_user_id *uid)
1051 {
1052   TRUSTREC trec, vrec;
1053   int rc;
1054   ulong recno;
1055   unsigned int validity;
1056   u32 kid[2];
1057   PKT_public_key *main_pk;
1058
1059   if(uid)
1060     namehash_from_uid(uid);
1061
1062   init_trustdb ();
1063   check_trustdb_stale();
1064
1065   keyid_from_pk (pk, kid);
1066   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
1067     { /* this is a subkey - get the mainkey */
1068       main_pk = m_alloc_clear (sizeof *main_pk);
1069       rc = get_pubkey (main_pk, pk->main_keyid);
1070       if (rc)
1071         {
1072           char *tempkeystr=m_strdup(keystr(pk->main_keyid));
1073           log_error ("error getting main key %s of subkey %s: %s\n",
1074                      tempkeystr, keystr(kid), g10_errstr(rc));
1075           m_free(tempkeystr);
1076           validity = TRUST_UNKNOWN; 
1077           goto leave;
1078         }
1079     }
1080   else
1081     main_pk = pk;
1082
1083   if(opt.trust_model==TM_DIRECT)
1084     {
1085       /* Note that this happens BEFORE any user ID stuff is checked.
1086          The direct trust model applies to keys as a whole. */
1087       validity=get_ownertrust(main_pk);
1088       goto leave;
1089     }
1090
1091   rc = read_trust_record (main_pk, &trec);
1092   if (rc && rc != -1)
1093     {
1094       tdbio_invalid ();
1095       return 0;
1096     }
1097   if (rc == -1) /* no record found */
1098     {
1099       validity = TRUST_UNKNOWN; 
1100       goto leave;
1101     }
1102
1103   /* loop over all user IDs */
1104   recno = trec.r.trust.validlist;
1105   validity = 0;
1106   while (recno)
1107     {
1108       read_record (recno, &vrec, RECTYPE_VALID);
1109
1110       if(uid)
1111         {
1112           /* If a user ID is given we return the validity for that
1113              user ID ONLY.  If the namehash is not found, then there
1114              is no validity at all (i.e. the user ID wasn't
1115              signed). */
1116           if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1117             {
1118               validity=(vrec.r.valid.validity & TRUST_MASK);
1119               break;
1120             }
1121         }
1122       else
1123         {
1124           /* If no namehash is given, we take the maximum validity
1125              over all user IDs */
1126           if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
1127             validity = (vrec.r.valid.validity & TRUST_MASK);
1128         }
1129
1130       recno = vrec.r.valid.next;
1131     }
1132   
1133   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
1134     {
1135       validity |= TRUST_FLAG_DISABLED;
1136       pk->is_disabled=2;
1137     }
1138   else
1139     pk->is_disabled=1;
1140
1141  leave:
1142   /* set some flags direct from the key */
1143   if (main_pk->is_revoked)
1144     validity |= TRUST_FLAG_REVOKED;
1145   if (main_pk != pk && pk->is_revoked)
1146     validity |= TRUST_FLAG_SUB_REVOKED;
1147   /* Note: expiration is a trust value and not a flag - don't know why
1148    * I initially designed it that way */
1149   if (main_pk->has_expired || pk->has_expired)
1150     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
1151   
1152   if (pending_check_trustdb)
1153     validity |= TRUST_FLAG_PENDING_CHECK;
1154
1155   if (main_pk != pk)
1156     free_public_key (main_pk);
1157   return validity;
1158 }
1159
1160 int
1161 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
1162 {
1163     int trustlevel;
1164
1165     trustlevel = get_validity (pk, uid);
1166     if( trustlevel & TRUST_FLAG_REVOKED )
1167         return 'r';
1168     return trust_letter ( trustlevel );
1169 }
1170
1171 const char *
1172 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
1173 {
1174   int trustlevel;
1175
1176   trustlevel = get_validity (pk, uid);
1177   if( trustlevel & TRUST_FLAG_REVOKED )
1178     return _("revoked");
1179   return trust_value_to_string(trustlevel);
1180 }
1181
1182 static void
1183 get_validity_counts (PKT_public_key *pk, PKT_user_id *uid)
1184 {
1185   TRUSTREC trec, vrec;
1186   ulong recno;
1187
1188   if(pk==NULL || uid==NULL)
1189     BUG();
1190
1191   namehash_from_uid(uid);
1192
1193   uid->help_marginal_count=uid->help_full_count=0;
1194
1195   init_trustdb ();
1196
1197   if(read_trust_record (pk, &trec)!=0)
1198     return;
1199
1200   /* loop over all user IDs */
1201   recno = trec.r.trust.validlist;
1202   while (recno)
1203     {
1204       read_record (recno, &vrec, RECTYPE_VALID);
1205
1206       if(memcmp(vrec.r.valid.namehash,uid->namehash,20)==0)
1207         {
1208           uid->help_marginal_count=vrec.r.valid.marginal_count;
1209           uid->help_full_count=vrec.r.valid.full_count;
1210           /*  printf("Fetched marginal %d, full %d\n",uid->help_marginal_count,uid->help_full_count); */
1211           break;
1212         }
1213
1214       recno = vrec.r.valid.next;
1215     }
1216 }
1217
1218 void
1219 list_trust_path( const char *username )
1220 {
1221 }
1222
1223 /****************
1224  * Enumerate all keys, which are needed to build all trust paths for
1225  * the given key.  This function does not return the key itself or
1226  * the ultimate key (the last point in cerificate chain).  Only
1227  * certificate chains which ends up at an ultimately trusted key
1228  * are listed.  If ownertrust or validity is not NULL, the corresponding
1229  * value for the returned LID is also returned in these variable(s).
1230  *
1231  *  1) create a void pointer and initialize it to NULL
1232  *  2) pass this void pointer by reference to this function.
1233  *     Set lid to the key you want to enumerate and pass it by reference.
1234  *  3) call this function as long as it does not return -1
1235  *     to indicate EOF. LID does contain the next key used to build the web
1236  *  4) Always call this function a last time with LID set to NULL,
1237  *     so that it can free its context.
1238  *
1239  * Returns: -1 on EOF or the level of the returned LID
1240  */
1241 int
1242 enum_cert_paths( void **context, ulong *lid,
1243                  unsigned *ownertrust, unsigned *validity )
1244 {
1245     return -1;
1246 }
1247
1248
1249 /****************
1250  * Print the current path
1251  */
1252 void
1253 enum_cert_paths_print( void **context, FILE *fp,
1254                                        int refresh, ulong selected_lid )
1255 {
1256     return;
1257 }
1258
1259
1260 \f
1261 /****************************************
1262  *********** NEW NEW NEW ****************
1263  ****************************************/
1264
1265 static int
1266 ask_ownertrust (u32 *kid,int minimum)
1267 {
1268   PKT_public_key *pk;
1269   int rc;
1270   int ot;
1271
1272   pk = m_alloc_clear (sizeof *pk);
1273   rc = get_pubkey (pk, kid);
1274   if (rc)
1275     {
1276       log_error (_("public key %s not found: %s\n"),
1277                  keystr(kid), g10_errstr(rc) );
1278       return TRUST_UNKNOWN;
1279     }
1280  
1281   if(opt.force_ownertrust)
1282     {
1283       log_info("force trust for key %s to %s\n",
1284                keystr(kid),trust_value_to_string(opt.force_ownertrust));
1285       update_ownertrust(pk,opt.force_ownertrust);
1286       ot=opt.force_ownertrust;
1287     }
1288   else
1289     {
1290       ot=edit_ownertrust(pk,0);
1291       if(ot>0)
1292         ot = get_ownertrust (pk);
1293       else if(ot==0)
1294         ot = minimum?minimum:TRUST_UNDEFINED;
1295       else
1296         ot = -1; /* quit */
1297     }
1298
1299   free_public_key( pk );
1300
1301   return ot;
1302 }
1303
1304
1305 static void
1306 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1307 {
1308   for ( ;node; node = node->next )
1309     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1310         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1311       {
1312         u32 aki[2];
1313
1314         keyid_from_pk (node->pkt->pkt.public_key, aki);
1315         add_key_hash_table (tbl, aki);
1316       }
1317 }
1318
1319
1320 static void
1321 dump_key_array (int depth, struct key_array *keys)
1322 {
1323   struct key_array *kar;
1324
1325   for (kar=keys; kar->keyblock; kar++)
1326     {
1327       KBNODE node = kar->keyblock;
1328       u32 kid[2];
1329
1330       keyid_from_pk(node->pkt->pkt.public_key, kid);
1331       printf ("%d:%08lX%08lX:K::%c::::\n",
1332               depth, (ulong)kid[0], (ulong)kid[1], '?');
1333
1334       for (; node; node = node->next)
1335         {
1336           if (node->pkt->pkttype == PKT_USER_ID)
1337             {
1338               int len = node->pkt->pkt.user_id->len;
1339
1340               if (len > 30)
1341                 len = 30;
1342               printf ("%d:%08lX%08lX:U:::%c:::",
1343                       depth, (ulong)kid[0], (ulong)kid[1],
1344                       (node->flag & 4)? 'f':
1345                       (node->flag & 2)? 'm':
1346                       (node->flag & 1)? 'q':'-');
1347               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1348               putchar (':');
1349               putchar ('\n');
1350             }
1351         }
1352     }
1353 }  
1354
1355
1356 static void
1357 store_validation_status (int depth, KBNODE keyblock, KeyHashTable stored)
1358 {
1359   KBNODE node;
1360   int status;
1361   int any = 0;
1362
1363   for (node=keyblock; node; node = node->next)
1364     {
1365       if (node->pkt->pkttype == PKT_USER_ID)
1366         {
1367           PKT_user_id *uid = node->pkt->pkt.user_id;
1368           if (node->flag & 4)
1369             status = TRUST_FULLY;
1370           else if (node->flag & 2)
1371             status = TRUST_MARGINAL;
1372           else if (node->flag & 1)
1373             status = TRUST_UNDEFINED;
1374           else
1375             status = 0;
1376           
1377           if (status)
1378             {
1379               update_validity (keyblock->pkt->pkt.public_key,
1380                                uid, depth, status);
1381
1382               mark_keyblock_seen(stored,keyblock);
1383
1384               any = 1;
1385             }
1386         }
1387     }
1388
1389   if (any)
1390     do_sync ();
1391 }  
1392
1393 /*
1394  * check whether the signature sig is in the klist k
1395  */
1396 static struct key_item *
1397 is_in_klist (struct key_item *k, PKT_signature *sig)
1398 {
1399   for (; k; k = k->next)
1400     {
1401       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1402         return k;
1403     }
1404   return NULL;
1405 }
1406
1407 /*
1408  * Mark the signature of the given UID which are used to certify it.
1409  * To do this, we first revmove all signatures which are not valid and
1410  * from the remain ones we look for the latest one.  If this is not a
1411  * certification revocation signature we mark the signature by setting
1412  * node flag bit 8.  Revocations are marked with flag 11, and sigs
1413  * from unavailable keys are marked with flag 12.  Note that flag bits
1414  * 9 and 10 are used for internal purposes.
1415  */
1416 static void
1417 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1418                        u32 *main_kid, struct key_item *klist,
1419                        u32 curtime, u32 *next_expire)
1420 {
1421   KBNODE node;
1422   PKT_signature *sig;
1423   
1424   /* first check all signatures */
1425   for (node=uidnode->next; node; node = node->next)
1426     {
1427       int rc;
1428
1429       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
1430       if (node->pkt->pkttype == PKT_USER_ID
1431           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1432         break; /* ready */
1433       if (node->pkt->pkttype != PKT_SIGNATURE)
1434         continue;
1435       sig = node->pkt->pkt.signature;
1436       if (main_kid
1437           && sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1438         continue; /* ignore self-signatures if we pass in a main_kid */
1439       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1440         continue; /* we only look at these signature classes */
1441       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
1442          sig->sig_class-0x10<opt.min_cert_level)
1443         continue; /* treat anything under our min_cert_level as an
1444                      invalid signature */
1445       if (klist && !is_in_klist (klist, sig))
1446         continue;  /* no need to check it then */
1447       if ((rc=check_key_signature (keyblock, node, NULL)))
1448         {
1449           /* we ignore anything that won't verify, but tag the
1450              no_pubkey case */
1451           if(rc==G10ERR_NO_PUBKEY)
1452             node->flag |= 1<<12;
1453           continue;
1454         }
1455       node->flag |= 1<<9;
1456     }      
1457   /* reset the remaining flags */
1458   for (; node; node = node->next)
1459       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
1460
1461   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1462    * bit 10 will be set by the loop to keep track of keyIDs already
1463    * processed, bit 8 will be set for the usable signatures, and bit
1464    * 11 will be set for usable revocations. */
1465
1466   /* for each cert figure out the latest valid one */
1467   for (node=uidnode->next; node; node = node->next)
1468     {
1469       KBNODE n, signode;
1470       u32 kid[2];
1471       u32 sigdate;
1472
1473       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1474         break;
1475       if ( !(node->flag & (1<<9)) )
1476         continue; /* not a node to look at */
1477       if ( (node->flag & (1<<10)) )
1478         continue; /* signature with a keyID already processed */
1479       node->flag |= (1<<10); /* mark this node as processed */
1480       sig = node->pkt->pkt.signature;
1481       signode = node;
1482       sigdate = sig->timestamp;
1483       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1484
1485       /* Now find the latest and greatest signature */
1486       for (n=uidnode->next; n; n = n->next)
1487         {
1488           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1489             break;
1490           if ( !(n->flag & (1<<9)) )
1491             continue;
1492           if ( (n->flag & (1<<10)) )
1493             continue; /* shortcut already processed signatures */
1494           sig = n->pkt->pkt.signature;
1495           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1496             continue;
1497           n->flag |= (1<<10); /* mark this node as processed */
1498
1499           /* If signode is nonrevocable and unexpired and n isn't,
1500              then take signode (skip).  It doesn't matter which is
1501              older: if signode was older then we don't want to take n
1502              as signode is nonrevocable.  If n was older then we're
1503              automatically fine. */
1504           
1505           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1506                !signode->pkt->pkt.signature->flags.revocable &&
1507                (signode->pkt->pkt.signature->expiredate==0 ||
1508                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1509              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1510                 !n->pkt->pkt.signature->flags.revocable &&
1511                 (n->pkt->pkt.signature->expiredate==0 ||
1512                  n->pkt->pkt.signature->expiredate>curtime))))
1513             continue;
1514
1515           /* If n is nonrevocable and unexpired and signode isn't,
1516              then take n.  Again, it doesn't matter which is older: if
1517              n was older then we don't want to take signode as n is
1518              nonrevocable.  If signode was older then we're
1519              automatically fine. */
1520           
1521           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1522                 !signode->pkt->pkt.signature->flags.revocable &&
1523                 (signode->pkt->pkt.signature->expiredate==0 ||
1524                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1525              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1526                !n->pkt->pkt.signature->flags.revocable &&
1527                (n->pkt->pkt.signature->expiredate==0 ||
1528                 n->pkt->pkt.signature->expiredate>curtime))))
1529             {
1530               signode = n;
1531               sigdate = sig->timestamp;
1532               continue;
1533             }
1534
1535           /* At this point, if it's newer, it goes in as the only
1536              remaining possibilities are signode and n are both either
1537              revocable or expired or both nonrevocable and unexpired.
1538              If the timestamps are equal take the later ordered
1539              packet, presuming that the key packets are hopefully in
1540              their original order. */
1541
1542           if (sig->timestamp >= sigdate)
1543             {
1544               signode = n;
1545               sigdate = sig->timestamp;
1546             }
1547         }
1548
1549       sig = signode->pkt->pkt.signature;
1550       if (IS_UID_SIG (sig))
1551         { /* this seems to be a usable one which is not revoked. 
1552            * Just need to check whether there is an expiration time,
1553            * We do the expired certification after finding a suitable
1554            * certification, the assumption is that a signator does not
1555            * want that after the expiration of his certificate the
1556            * system falls back to an older certification which has a
1557            * different expiration time */
1558           const byte *p;
1559           u32 expire;
1560                     
1561           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1562           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1563
1564           if (expire==0 || expire > curtime )
1565             {
1566               signode->flag |= (1<<8); /* yeah, found a good cert */
1567               if (next_expire && expire && expire < *next_expire)
1568                 *next_expire = expire;
1569             }
1570         }
1571       else
1572         signode->flag |= (1<<11);
1573     }
1574 }
1575
1576 int
1577 clean_sigs_from_uid(KBNODE keyblock,KBNODE uidnode,int noisy)
1578 {
1579   int deleted=0;
1580   KBNODE node;
1581
1582   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1583
1584   /* Passing in a 0 for current time here means that we'll never weed
1585      out an expired sig.  This is correct behavior since we want to
1586      keep the most recent expired sig in a series. */
1587   mark_usable_uid_certs(keyblock,uidnode,NULL,NULL,0,NULL);
1588
1589   /* What we want to do here is remove signatures that are not
1590      considered as part of the trust calculations.  Thus, all invalid
1591      signatures are out, as are any signatures that aren't the last of
1592      a series of uid sigs or revocations It breaks down like this:
1593      coming out of mark_usable_uid_certs, if a sig is unflagged, it is
1594      not even a candidate.  If a sig has flag 9 or 10, that means it
1595      was selected as a candidate and vetted.  If a sig has flag 8 it
1596      is a usable signature.  If a sig has flag 11 it is a usable
1597      revocation.  If a sig has flag 12 it was issued by an unavailable
1598      key.  "Usable" here means the most recent valid
1599      signature/revocation in a series from a particular signer.
1600
1601      Delete everything that isn't a usable uid sig (which might be
1602      expired), a usable revocation, or a sig from an unavailable
1603      key. */
1604
1605   for(node=uidnode->next;
1606       node && node->pkt->pkttype==PKT_SIGNATURE;
1607       node=node->next)
1608     {
1609       /* Keep usable uid sigs ... */
1610       if(node->flag & (1<<8))
1611         continue;
1612
1613       /* ... and usable revocations... */
1614       if(node->flag & (1<<11))
1615         continue;
1616
1617       /* ... and sigs from unavailable keys. */
1618       if(node->flag & (1<<12))
1619         continue;
1620
1621       /* Everything else we delete */
1622
1623       /* if 9 or 10 is set, but we get this far, it's superceded,
1624          otherwise, it's invalid */
1625
1626       if(noisy)
1627         log_info("removing signature issued by key %s: %s\n",
1628                  keystr(node->pkt->pkt.signature->keyid),
1629                  node->flag&(1<<9)?"superceded":"invalid");
1630
1631       delete_kbnode(node);
1632       deleted++;
1633     }
1634     
1635   return deleted;
1636 }
1637
1638 /* This is substantially easier than clean_sigs_from_uid since we just
1639    have to establish if the uid has a valid self-sig, is not revoked,
1640    and is not expired.  Note that this does not take into account
1641    whether the uid has a trust path to it - just whether the keyholder
1642    themselves has certified the uid.  Returns how many user IDs were
1643    removed. */
1644 int
1645 clean_uids_from_key(KBNODE keyblock,int noisy)
1646 {
1647   int uidcount=0,delete_until_next=0,deleted=0;
1648   KBNODE node;
1649
1650   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1651
1652   merge_keys_and_selfsig(keyblock);
1653
1654   /* First count how many user IDs we have.  We need to be careful
1655      that we don't delete them all as some keys could actually have NO
1656      valid user IDs.  2440 requires at least 1 user ID packet, valid
1657      or not. */
1658   for(node=keyblock->next;
1659       node && node->pkt->pkttype!=PKT_PUBLIC_SUBKEY;
1660       node=node->next)
1661     if(node->pkt->pkttype==PKT_USER_ID)
1662       uidcount++;
1663
1664   for(node=keyblock->next;
1665       node && node->pkt->pkttype!=PKT_PUBLIC_SUBKEY && uidcount>deleted+1;
1666       node=node->next)
1667     {
1668       if(node->pkt->pkttype==PKT_USER_ID)
1669         {
1670           PKT_user_id *uid=node->pkt->pkt.user_id;
1671
1672           /* Skip valid user IDs, and non-self-signed user IDs if
1673              --allow-non-selfsigned-uid is set. */
1674           if(uid->created
1675              || (!uid->is_expired && !uid->is_revoked 
1676                  && opt.allow_non_selfsigned_uid))
1677             delete_until_next=0;
1678           else
1679             {
1680               delete_until_next=1;
1681               deleted++;
1682
1683               if(noisy)
1684                 {
1685                   char *reason;
1686                   char *user=utf8_to_native(uid->name,uid->len,0);
1687
1688                   if(uid->is_revoked)
1689                     reason=_("revoked");
1690                   else if(uid->is_expired)
1691                     reason=_("expired");
1692                   else
1693                     reason=_("invalid");
1694
1695                   log_info("removing user ID \"%s\" from key %s: %s\n",
1696                            user,keystr(keyblock->pkt->pkt.public_key->keyid),
1697                            reason);
1698
1699                   m_free(user);
1700                 }
1701             }
1702         }
1703
1704       if(delete_until_next)
1705         delete_kbnode(node);
1706     }
1707     
1708   return deleted;
1709 }
1710
1711 /* Another cleaning function.  This only cleans encrypt-only subkeys
1712    since an expired/revoked encryption key is basically useless, but
1713    an expired/revoked key that can sign is still needed to verify old
1714    signatures. */
1715 int
1716 clean_subkeys_from_key(KBNODE keyblock,int noisy)
1717 {
1718   int delete_until_next=0,deleted=0;
1719   KBNODE node;
1720   char *main_key=NULL;
1721
1722   assert(keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
1723
1724   merge_keys_and_selfsig(keyblock);
1725
1726   if(noisy)
1727     main_key=m_strdup(keystr(keyblock->pkt->pkt.public_key->keyid));
1728
1729   for(node=keyblock->next;node;node=node->next)
1730     {
1731       if(node->pkt->pkttype==PKT_PUBLIC_SUBKEY)
1732         {
1733           PKT_public_key *pk=node->pkt->pkt.public_key;
1734
1735           /* If it is valid, not expired, and not revoked, leave it
1736              alone.  If a key can make signatures, leave it alone. */
1737           if(pk->pubkey_usage!=PUBKEY_USAGE_ENC
1738              || (pk->is_valid && !pk->has_expired && !pk->is_revoked))
1739             delete_until_next=0;
1740           else
1741             {
1742               delete_until_next=1;
1743               deleted++;
1744
1745               if(noisy)
1746                 {
1747                   char *reason;
1748
1749                   if(pk->is_revoked)
1750                     reason=_("revoked");
1751                   else if(pk->has_expired)
1752                     reason=_("expired");
1753                   else
1754                     reason=_("invalid");
1755
1756                   log_info("removing subkey %s from key %s: %s\n",
1757                            keystr_from_pk(pk),main_key,reason);
1758                 }
1759             }
1760         }
1761
1762       if(delete_until_next)
1763         delete_kbnode(node);
1764     }
1765
1766   m_free(main_key);
1767
1768   return deleted;
1769 }
1770
1771 /* Used by validate_one_keyblock to confirm a regexp within a trust
1772    signature.  Returns 1 for match, and 0 for no match or regex
1773    error. */
1774 static int
1775 check_regexp(const char *expr,const char *string)
1776 {
1777 #ifdef DISABLE_REGEX
1778   /* When DISABLE_REGEX is defined, assume all regexps do not
1779      match. */
1780   return 0;
1781 #elif defined(__riscos__)
1782   return riscos_check_regexp(expr, string, DBG_TRUST);
1783 #else
1784   int ret;
1785   regex_t pat;
1786
1787   if(regcomp(&pat,expr,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1788     return 0;
1789
1790   ret=regexec(&pat,string,0,NULL,0);
1791
1792   regfree(&pat);
1793
1794   if(DBG_TRUST)
1795     log_debug("regexp `%s' on `%s': %s\n",expr,string,ret==0?"YES":"NO");
1796
1797   return (ret==0);
1798 #endif
1799 }
1800
1801 /*
1802  * Return true if the key is signed by one of the keys in the given
1803  * key ID list.  User IDs with a valid signature are marked by node
1804  * flags as follows:
1805  *  flag bit 0: There is at least one signature
1806  *           1: There is marginal confidence that this is a legitimate uid
1807  *           2: There is full confidence that this is a legitimate uid.
1808  *           8: Used for internal purposes.
1809  *           9: Ditto (in mark_usable_uid_certs())
1810  *          10: Ditto (ditto)
1811  * This function assumes that all kbnode flags are cleared on entry.
1812  */
1813 static int
1814 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1815                        u32 curtime, u32 *next_expire)
1816 {
1817   struct key_item *kr;
1818   KBNODE node, uidnode=NULL;
1819   PKT_user_id *uid=NULL;
1820   PKT_public_key *pk = kb->pkt->pkt.public_key;
1821   u32 main_kid[2];
1822   int issigned=0, any_signed = 0;
1823
1824   keyid_from_pk(pk, main_kid);
1825   for (node=kb; node; node = node->next)
1826     {
1827       /* A bit of discussion here: is it better for the web of trust
1828          to be built among only self-signed uids?  On the one hand, a
1829          self-signed uid is a statement that the key owner definitely
1830          intended that uid to be there, but on the other hand, a
1831          signed (but not self-signed) uid does carry trust, of a sort,
1832          even if it is a statement being made by people other than the
1833          key owner "through" the uids on the key owner's key.  I'm
1834          going with the latter.  However, if the user ID was
1835          explicitly revoked, or passively allowed to expire, that
1836          should stop validity through the user ID until it is
1837          resigned.  -dshaw */
1838
1839       if (node->pkt->pkttype == PKT_USER_ID
1840           && !node->pkt->pkt.user_id->is_revoked
1841           && !node->pkt->pkt.user_id->is_expired)
1842         {
1843           if (uidnode && issigned)
1844             {
1845               if (uid->help_full_count >= opt.completes_needed
1846                   || uid->help_marginal_count >= opt.marginals_needed )
1847                 uidnode->flag |= 4; 
1848               else if (uid->help_full_count || uid->help_marginal_count)
1849                 uidnode->flag |= 2;
1850               uidnode->flag |= 1;
1851               any_signed = 1;
1852             }
1853           uidnode = node;
1854           uid=uidnode->pkt->pkt.user_id;
1855
1856           /* If the selfsig is going to expire... */
1857           if(uid->expiredate && uid->expiredate<*next_expire)
1858             *next_expire = uid->expiredate;
1859
1860           issigned = 0;
1861           get_validity_counts(pk,uid);
1862           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1863                                  curtime, next_expire);
1864         }
1865       else if (node->pkt->pkttype == PKT_SIGNATURE
1866                && (node->flag & (1<<8)) && uid)
1867         {
1868           /* Note that we are only seeing unrevoked sigs here */
1869           PKT_signature *sig = node->pkt->pkt.signature;
1870           
1871           kr = is_in_klist (klist, sig);
1872           /* If the trust_regexp does not match, it's as if the sig
1873              did not exist.  This is safe for non-trust sigs as well
1874              since we don't accept a regexp on the sig unless it's a
1875              trust sig. */
1876           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_PGP ||
1877                      (uidnode && check_regexp(kr->trust_regexp,
1878                                             uidnode->pkt->pkt.user_id->name))))
1879             {
1880               if(DBG_TRUST && opt.trust_model==TM_PGP && sig->trust_depth)
1881                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1882                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1883                           kr->trust_depth);
1884
1885               /* Are we part of a trust sig chain?  We always favor
1886                  the latest trust sig, rather than the greater or
1887                  lesser trust sig or value.  I could make a decent
1888                  argument for any of these cases, but this seems to be
1889                  what PGP does, and I'd like to be compatible. -dms */
1890               if(opt.trust_model==TM_PGP && sig->trust_depth
1891                  && pk->trust_timestamp<=sig->timestamp
1892                  && (sig->trust_depth<=kr->trust_depth
1893                      || kr->ownertrust==TRUST_ULTIMATE))
1894                 {
1895                   /* If we got here, we know that:
1896
1897                      this is a trust sig.
1898
1899                      it's a newer trust sig than any previous trust
1900                      sig on this key (not uid).
1901
1902                      it is legal in that it was either generated by an
1903                      ultimate key, or a key that was part of a trust
1904                      chain, and the depth does not violate the
1905                      original trust sig.
1906
1907                      if there is a regexp attached, it matched
1908                      successfully.
1909                   */
1910
1911                   if(DBG_TRUST)
1912                     log_debug("replacing trust value %d with %d and "
1913                               "depth %d with %d\n",
1914                               pk->trust_value,sig->trust_value,
1915                               pk->trust_depth,sig->trust_depth);
1916
1917                   pk->trust_value=sig->trust_value;
1918                   pk->trust_depth=sig->trust_depth-1;
1919
1920                   /* If the trust sig contains a regexp, record it
1921                      on the pk for the next round. */
1922                   if(sig->trust_regexp)
1923                     pk->trust_regexp=sig->trust_regexp;
1924                 }
1925
1926               if (kr->ownertrust == TRUST_ULTIMATE)
1927                 uid->help_full_count = opt.completes_needed;
1928               else if (kr->ownertrust == TRUST_FULLY)
1929                 uid->help_full_count++;
1930               else if (kr->ownertrust == TRUST_MARGINAL)
1931                 uid->help_marginal_count++;
1932               issigned = 1;
1933             }
1934         }
1935     }
1936
1937   if (uidnode && issigned)
1938     {
1939       if (uid->help_full_count >= opt.completes_needed
1940           || uid->help_marginal_count >= opt.marginals_needed )
1941         uidnode->flag |= 4; 
1942       else if (uid->help_full_count || uid->help_marginal_count)
1943         uidnode->flag |= 2;
1944       uidnode->flag |= 1;
1945       any_signed = 1;
1946     }
1947
1948   return any_signed;
1949 }
1950
1951
1952 static int
1953 search_skipfnc (void *opaque, u32 *kid, PKT_user_id *dummy)
1954 {
1955   return test_key_hash_table ((KeyHashTable)opaque, kid);
1956 }
1957
1958
1959 /*
1960  * Scan all keys and return a key_array of all suitable keys from
1961  * kllist.  The caller has to pass keydb handle so that we don't use
1962  * to create our own.  Returns either a key_array or NULL in case of
1963  * an error.  No results found are indicated by an empty array.
1964  * Caller hast to release the returned array.  
1965  */
1966 static struct key_array *
1967 validate_key_list (KEYDB_HANDLE hd, KeyHashTable full_trust,
1968                    struct key_item *klist, u32 curtime, u32 *next_expire)
1969 {
1970   KBNODE keyblock = NULL;
1971   struct key_array *keys = NULL;
1972   size_t nkeys, maxkeys;
1973   int rc;
1974   KEYDB_SEARCH_DESC desc;
1975   
1976   maxkeys = 1000;
1977   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1978   nkeys = 0;
1979   
1980   rc = keydb_search_reset (hd);
1981   if (rc)
1982     {
1983       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1984       m_free (keys);
1985       return NULL;
1986     }
1987
1988   memset (&desc, 0, sizeof desc);
1989   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1990   desc.skipfnc = search_skipfnc;
1991   desc.skipfncvalue = full_trust;
1992   rc = keydb_search (hd, &desc, 1);
1993   if (rc == -1)
1994     {
1995       keys[nkeys].keyblock = NULL;
1996       return keys;
1997     }
1998   if (rc)
1999     {
2000       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
2001       m_free (keys);
2002       return NULL;
2003     }
2004   
2005   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
2006   do
2007     {
2008       PKT_public_key *pk;
2009         
2010       rc = keydb_get_keyblock (hd, &keyblock);
2011       if (rc) 
2012         {
2013           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
2014           m_free (keys);
2015           return NULL;
2016         }
2017       
2018       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
2019         {
2020           log_debug ("ooops: invalid pkttype %d encountered\n",
2021                      keyblock->pkt->pkttype);
2022           dump_kbnode (keyblock);
2023           release_kbnode(keyblock);
2024           continue;
2025         }
2026
2027       /* prepare the keyblock for further processing */
2028       merge_keys_and_selfsig (keyblock); 
2029       clear_kbnode_flags (keyblock);
2030       pk = keyblock->pkt->pkt.public_key;
2031       if (pk->has_expired || pk->is_revoked)
2032         {
2033           /* it does not make sense to look further at those keys */
2034           mark_keyblock_seen (full_trust, keyblock);
2035         }
2036       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
2037         {
2038           KBNODE node;
2039
2040           if (pk->expiredate && pk->expiredate >= curtime
2041               && pk->expiredate < *next_expire)
2042             *next_expire = pk->expiredate;
2043
2044           if (nkeys == maxkeys) {
2045             maxkeys += 1000;
2046             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
2047           }
2048           keys[nkeys++].keyblock = keyblock;
2049
2050           /* Optimization - if all uids are fully trusted, then we
2051              never need to consider this key as a candidate again. */
2052
2053           for (node=keyblock; node; node = node->next)
2054             if (node->pkt->pkttype == PKT_USER_ID && !(node->flag & 4))
2055               break;
2056
2057           if(node==NULL)
2058             mark_keyblock_seen (full_trust, keyblock);
2059
2060           keyblock = NULL;
2061         }
2062
2063       release_kbnode (keyblock);
2064       keyblock = NULL;
2065     } 
2066   while ( !(rc = keydb_search (hd, &desc, 1)) );
2067   if (rc && rc != -1) 
2068     {
2069       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
2070       m_free (keys);
2071       return NULL;
2072     }
2073
2074   keys[nkeys].keyblock = NULL;
2075   return keys;
2076
2077
2078 /* Caller must sync */
2079 static void
2080 reset_trust_records(void)
2081 {
2082   TRUSTREC rec;
2083   ulong recnum;
2084   int count = 0, nreset = 0;
2085
2086   for (recnum=1; !tdbio_read_record (recnum, &rec, 0); recnum++ ) 
2087     {
2088       if(rec.rectype==RECTYPE_TRUST)
2089         {
2090           count++;
2091           if(rec.r.trust.min_ownertrust)
2092             {
2093               rec.r.trust.min_ownertrust=0;
2094               write_record(&rec);
2095             }
2096
2097         }
2098       else if(rec.rectype==RECTYPE_VALID
2099               && ((rec.r.valid.validity&TRUST_MASK)
2100                   || rec.r.valid.marginal_count
2101                   || rec.r.valid.full_count))
2102         {
2103           rec.r.valid.validity &= ~TRUST_MASK;
2104           rec.r.valid.marginal_count=rec.r.valid.full_count=0;
2105           nreset++;
2106           write_record(&rec);
2107         }
2108
2109     }
2110
2111   if (opt.verbose)
2112     log_info (_("%d keys processed (%d validity counts cleared)\n"),
2113               count, nreset);
2114 }
2115
2116 /*
2117  * Run the key validation procedure.
2118  *
2119  * This works this way:
2120  * Step 1: Find all ultimately trusted keys (UTK).
2121  *         mark them all as seen and put them into klist.
2122  * Step 2: loop max_cert_times
2123  * Step 3:   if OWNERTRUST of any key in klist is undefined
2124  *             ask user to assign ownertrust
2125  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
2126  * Step 5:     if key is revoked or expired
2127  *                mark key as seen
2128  *                continue loop at Step 4
2129  * Step 6:     For each user ID of that key signed by a key in klist
2130  *                Calculate validity by counting trusted signatures.
2131  *                Set validity of user ID
2132  * Step 7:     If any signed user ID was found
2133  *                mark key as seen
2134  *             End Loop
2135  * Step 8:   Build a new klist from all fully trusted keys from step 6
2136  *           End Loop
2137  *         Ready  
2138  *
2139  */
2140 static int
2141 validate_keys (int interactive)
2142 {
2143   int rc = 0;
2144   int quit=0;
2145   struct key_item *klist = NULL;
2146   struct key_item *k;
2147   struct key_array *keys = NULL;
2148   struct key_array *kar;
2149   KEYDB_HANDLE kdb = NULL;
2150   KBNODE node;
2151   int depth;
2152   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
2153   KeyHashTable stored,used,full_trust;
2154   u32 start_time, next_expire;
2155
2156   /* Make sure we have all sigs cached.  TODO: This is going to
2157      require some architectual re-thinking, as it is agonizingly slow.
2158      Perhaps combine this with reset_trust_records(), or only check
2159      the caches on keys that are actually involved in the web of
2160      trust. */
2161   keydb_rebuild_caches(0);
2162
2163   start_time = make_timestamp ();
2164   next_expire = 0xffffffff; /* set next expire to the year 2106 */
2165   stored = new_key_hash_table ();
2166   used = new_key_hash_table ();
2167   full_trust = new_key_hash_table ();
2168
2169   kdb = keydb_new (0);
2170   reset_trust_records();
2171
2172   /* Fixme: Instead of always building a UTK list, we could just build it
2173    * here when needed */
2174   if (!utk_list)
2175     {
2176       log_info (_("no ultimately trusted keys found\n"));
2177       goto leave;
2178     }
2179
2180   /* mark all UTKs as used and fully_trusted and set validity to
2181      ultimate */
2182   for (k=utk_list; k; k = k->next)
2183     {
2184       KBNODE keyblock;
2185       PKT_public_key *pk;
2186
2187       keyblock = get_pubkeyblock (k->kid);
2188       if (!keyblock)
2189         {
2190           log_error (_("public key of ultimately"
2191                        " trusted key %s not found\n"), keystr(k->kid));
2192           continue;
2193         }
2194       mark_keyblock_seen (used, keyblock);
2195       mark_keyblock_seen (stored, keyblock);
2196       mark_keyblock_seen (full_trust, keyblock);
2197       pk = keyblock->pkt->pkt.public_key;
2198       for (node=keyblock; node; node = node->next)
2199         {
2200           if (node->pkt->pkttype == PKT_USER_ID)
2201             update_validity (pk, node->pkt->pkt.user_id, 0, TRUST_ULTIMATE);
2202         }
2203       if ( pk->expiredate && pk->expiredate >= start_time
2204            && pk->expiredate < next_expire)
2205         next_expire = pk->expiredate;
2206       
2207       release_kbnode (keyblock);
2208       do_sync ();
2209     }
2210
2211   klist = utk_list;
2212
2213   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
2214            opt.marginals_needed,opt.completes_needed,trust_model_string());
2215
2216   for (depth=0; depth < opt.max_cert_depth; depth++)
2217     {
2218       int valids=0,key_count;
2219       /* See whether we should assign ownertrust values to the keys in
2220          klist.  */
2221       ot_unknown = ot_undefined = ot_never = 0;
2222       ot_marginal = ot_full = ot_ultimate = 0;
2223       for (k=klist; k; k = k->next)
2224         {
2225           int min=0;
2226
2227           /* 120 and 60 are as per RFC2440 */
2228           if(k->trust_value>=120)
2229             min=TRUST_FULLY;
2230           else if(k->trust_value>=60)
2231             min=TRUST_MARGINAL;
2232
2233           if(min!=k->min_ownertrust)
2234             update_min_ownertrust(k->kid,min);
2235
2236           if (interactive && k->ownertrust == TRUST_UNKNOWN)
2237             {
2238               k->ownertrust = ask_ownertrust (k->kid,min);
2239
2240               if (k->ownertrust == -1)
2241                 {
2242                   quit=1;
2243                   goto leave;
2244                 }
2245             }
2246
2247           /* This can happen during transition from an old trustdb
2248              before trust sigs.  It can also happen if a user uses two
2249              different versions of GnuPG or changes the --trust-model
2250              setting. */
2251           if(k->ownertrust<min)
2252             {
2253               if(DBG_TRUST)
2254                 log_debug("key %08lX%08lX:"
2255                           " overriding ownertrust `%s' with `%s'\n",
2256                           (ulong)k->kid[0],(ulong)k->kid[1],
2257                           trust_value_to_string(k->ownertrust),
2258                           trust_value_to_string(min));
2259
2260               k->ownertrust=min;
2261             }
2262
2263           if (k->ownertrust == TRUST_UNKNOWN)
2264             ot_unknown++;
2265           else if (k->ownertrust == TRUST_UNDEFINED)
2266             ot_undefined++;
2267           else if (k->ownertrust == TRUST_NEVER)
2268             ot_never++;
2269           else if (k->ownertrust == TRUST_MARGINAL)
2270             ot_marginal++;
2271           else if (k->ownertrust == TRUST_FULLY)
2272             ot_full++;
2273           else if (k->ownertrust == TRUST_ULTIMATE)
2274             ot_ultimate++;
2275
2276           valids++;
2277         }
2278
2279       /* Find all keys which are signed by a key in kdlist */
2280       keys = validate_key_list (kdb, full_trust, klist,
2281                                 start_time, &next_expire);
2282       if (!keys) 
2283         {
2284           log_error ("validate_key_list failed\n");
2285           rc = G10ERR_GENERAL;
2286           goto leave;
2287         }
2288
2289       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
2290         ;
2291
2292       /* Store the calculated valididation status somewhere */
2293       if (opt.verbose > 1)
2294         dump_key_array (depth, keys);
2295
2296       for (kar=keys; kar->keyblock; kar++)
2297           store_validation_status (depth, kar->keyblock, stored);
2298
2299       log_info (_("depth: %d  valid: %3d  signed: %3d"
2300                   "  trust: %d-, %dq, %dn, %dm, %df, %du\n"), 
2301                 depth, valids, key_count, ot_unknown, ot_undefined,
2302                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
2303
2304       /* Build a new kdlist from all fully valid keys in KEYS */
2305       if (klist != utk_list)
2306         release_key_items (klist);
2307       klist = NULL;
2308       for (kar=keys; kar->keyblock; kar++)
2309         {
2310           for (node=kar->keyblock; node; node = node->next)
2311             {
2312               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
2313                 {
2314                   u32 kid[2];
2315
2316                   /* have we used this key already? */
2317                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, kid);
2318                   if(test_key_hash_table(used,kid)==0)
2319                     {
2320                       /* Normally we add both the primary and subkey
2321                          ids to the hash via mark_keyblock_seen, but
2322                          since we aren't using this hash as a skipfnc,
2323                          that doesn't matter here. */
2324                       add_key_hash_table (used,kid);
2325                       k = new_key_item ();
2326                       k->kid[0]=kid[0];
2327                       k->kid[1]=kid[1];
2328                       k->ownertrust =
2329                         (get_ownertrust (kar->keyblock->pkt->pkt.public_key)
2330                          & TRUST_MASK);
2331                       k->min_ownertrust =
2332                         get_min_ownertrust(kar->keyblock->pkt->pkt.public_key);
2333                       k->trust_depth=
2334                         kar->keyblock->pkt->pkt.public_key->trust_depth;
2335                       k->trust_value=
2336                         kar->keyblock->pkt->pkt.public_key->trust_value;
2337                       if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
2338                         k->trust_regexp=
2339                           m_strdup(kar->keyblock->pkt->
2340                                    pkt.public_key->trust_regexp);
2341                       k->next = klist;
2342                       klist = k;
2343                       break;
2344                     }
2345                 }
2346             }
2347         }
2348       release_key_array (keys);
2349       keys = NULL;
2350       if (!klist)
2351         break; /* no need to dive in deeper */
2352     }
2353
2354  leave:
2355   keydb_release (kdb);
2356   release_key_array (keys);
2357   release_key_items (klist);
2358   release_key_hash_table (full_trust);
2359   release_key_hash_table (used);
2360   release_key_hash_table (stored);
2361   if (!rc && !quit) /* mark trustDB as checked */
2362     {
2363       if (next_expire == 0xffffffff || next_expire < start_time )
2364         tdbio_write_nextcheck (0); 
2365       else
2366         {
2367           tdbio_write_nextcheck (next_expire); 
2368           log_info (_("next trustdb check due at %s\n"),
2369                     strtimestamp (next_expire));
2370         }
2371
2372       if(tdbio_update_version_record()!=0)
2373         {
2374           log_error(_("unable to update trustdb version record: "
2375                       "write failed: %s\n"), g10_errstr(rc));
2376           tdbio_invalid();
2377         }
2378
2379       do_sync ();
2380       pending_check_trustdb = 0;
2381     }
2382
2383   return rc;
2384 }