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