c3041370c2c2611427aca259630ae84bbf6be707
[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   if(!tdbio_db_matches_options())
429     pending_check_trustdb=1;
430 }
431
432
433
434 \f
435 /***********************************************
436  *************  Print helpers   ****************
437  ***********************************************/
438
439 /****************
440  * This function returns a letter for a trustvalue  Trust flags
441  * are ignore.
442  */
443 int
444 trust_letter (unsigned int value)
445 {
446   switch( (value & TRUST_MASK) ) 
447     {
448     case TRUST_UNKNOWN:   return '-';
449     case TRUST_EXPIRED:   return 'e';
450     case TRUST_UNDEFINED: return 'q';
451     case TRUST_NEVER:     return 'n';
452     case TRUST_MARGINAL:  return 'm';
453     case TRUST_FULLY:     return 'f';
454     case TRUST_ULTIMATE:  return 'u';
455     default:              return 0;
456     }
457 }
458
459 /* The strings here are similar to those in
460    pkclist.c:do_edit_ownertrust() */
461 const char *
462 trust_string (unsigned int value)
463 {
464   switch( (value & TRUST_MASK) ) 
465     {
466     case TRUST_UNKNOWN:   return _("unknown trust");
467     case TRUST_EXPIRED:   return _("expired");
468     case TRUST_UNDEFINED: return _("undefined trust");
469     case TRUST_NEVER:     return _("do NOT trust");
470     case TRUST_MARGINAL:  return _("marginal trust");
471     case TRUST_FULLY:     return _("full trust");
472     case TRUST_ULTIMATE:  return _("ultimate trust");
473     default:              return "err";
474     }
475 }
476
477 static const char *
478 trust_model_string(void)
479 {
480   switch(opt.trust_model)
481     {
482     case TM_OPENPGP: return "OpenPGP";
483     case TM_CLASSIC: return "classic";
484     case TM_ALWAYS:  return "always";
485     default:         return "unknown";
486     }
487 }
488
489 /****************
490  * Recreate the WoT but do not ask for new ownertrusts.  Special
491  * feature: In batch mode and without a forced yes, this is only done
492  * when a check is due.  This can be used to run the check from a crontab
493  */
494 void
495 check_trustdb ()
496 {
497   if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
498     {
499       init_trustdb();
500       if (opt.batch && !opt.answer_yes)
501         {
502           ulong scheduled;
503
504           scheduled = tdbio_read_nextcheck ();
505           if (!scheduled)
506             {
507               log_info (_("no need for a trustdb check\n"));
508               return;
509             }
510
511           if (scheduled > make_timestamp ())
512             {
513               log_info (_("next trustdb check due at %s\n"),
514                         strtimestamp (scheduled));
515               return;
516             }
517         }
518
519       validate_keys (0);
520     }
521   else
522     log_info (_("no need for a trustdb check with \"%s\" trust model\n"),
523               trust_model_string());
524 }
525
526
527 /*
528  * Recreate the WoT. 
529  */
530 void
531 update_trustdb()
532 {
533   if(opt.trust_model==TM_OPENPGP || opt.trust_model==TM_CLASSIC)
534     {
535       init_trustdb();
536       validate_keys (1);
537     }
538   else
539     log_info (_("no need for a trustdb update with \"%s\" trust model\n"),
540               trust_model_string());
541 }
542
543 void
544 revalidation_mark (void)
545 {
546   init_trustdb();
547   /* we simply set the time for the next check to 1 (far back in 1970)
548    * so that a --update-trustdb will be scheduled */
549   if (tdbio_write_nextcheck (1))
550       do_sync ();
551   pending_check_trustdb = 1;
552 }
553
554 int
555 trustdb_pending_check(void)
556 {
557   return pending_check_trustdb;
558 }
559
560 \f
561 /***********************************************
562  ***********  Ownertrust et al. ****************
563  ***********************************************/
564
565 static int 
566 read_trust_record (PKT_public_key *pk, TRUSTREC *rec)
567 {
568   int rc;
569   
570   init_trustdb();
571   rc = tdbio_search_trust_bypk (pk, rec);
572   if (rc == -1)
573     return -1; /* no record yet */
574   if (rc) 
575     {
576       log_error ("trustdb: searching trust record failed: %s\n",
577                  g10_errstr (rc));
578       return rc; 
579     }
580       
581   if (rec->rectype != RECTYPE_TRUST)
582     {
583       log_error ("trustdb: record %lu is not a trust record\n",
584                  rec->recnum);
585       return G10ERR_TRUSTDB; 
586     }      
587   
588   return 0;
589 }
590
591 /****************
592  * Return the assigned ownertrust value for the given public key.
593  * The key should be the primary key.
594  */
595 unsigned int 
596 get_ownertrust ( PKT_public_key *pk)
597 {
598   TRUSTREC rec;
599   int rc;
600   
601   rc = read_trust_record (pk, &rec);
602   if (rc == -1)
603     return TRUST_UNKNOWN; /* no record yet */
604   if (rc) 
605     {
606       tdbio_invalid ();
607       return rc; /* actually never reached */
608     }
609
610   return rec.r.trust.ownertrust;
611 }
612
613 unsigned int 
614 get_min_ownertrust (PKT_public_key *pk)
615 {
616   TRUSTREC rec;
617   int rc;
618   
619   rc = read_trust_record (pk, &rec);
620   if (rc == -1)
621     return TRUST_UNKNOWN; /* no record yet */
622   if (rc) 
623     {
624       tdbio_invalid ();
625       return rc; /* actually never reached */
626     }
627
628   return rec.r.trust.min_ownertrust;
629 }
630
631 /*
632  * Same as get_ownertrust but return a trust letter instead of an value.
633  */
634 int
635 get_ownertrust_info (PKT_public_key *pk)
636 {
637     unsigned int otrust,otrust_min;
638     int c;
639
640     otrust = get_ownertrust (pk);
641     otrust_min = get_min_ownertrust (pk);
642     if(otrust<otrust_min)
643       {
644         /* If the trust that the user has set is less than the trust
645            that was calculated from a trust signature chain, use the
646            higher of the two.  We do this here and not in
647            get_ownertrust since the underlying ownertrust should not
648            really be set - just the appearance of the ownertrust. */
649
650         otrust=otrust_min;
651       }
652
653     c = trust_letter( (otrust & TRUST_MASK) );
654     if( !c )
655         c = '?';
656     return c;
657 }
658
659 /*
660  * Set the trust value of the given public key to the new value.
661  * The key should be a primary one.
662  */
663 void
664 update_ownertrust (PKT_public_key *pk, unsigned int new_trust )
665 {
666   TRUSTREC rec;
667   int rc;
668   
669   rc = read_trust_record (pk, &rec);
670   if (!rc)
671     {
672       if (DBG_TRUST)
673         log_debug ("update ownertrust from %u to %u\n",
674                    (unsigned int)rec.r.trust.ownertrust, new_trust );
675       if (rec.r.trust.ownertrust != new_trust)
676         {
677           rec.r.trust.ownertrust = new_trust;
678           write_record( &rec );
679           revalidation_mark ();
680           do_sync ();
681         }
682     }
683   else if (rc == -1)
684     { /* no record yet - create a new one */
685       size_t dummy;
686
687       if (DBG_TRUST)
688         log_debug ("insert ownertrust %u\n", new_trust );
689
690       memset (&rec, 0, sizeof rec);
691       rec.recnum = tdbio_new_recnum ();
692       rec.rectype = RECTYPE_TRUST;
693       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
694       rec.r.trust.ownertrust = new_trust;
695       write_record (&rec);
696       revalidation_mark ();
697       do_sync ();
698       rc = 0;
699     }
700   else 
701     {
702       tdbio_invalid ();
703     }
704 }
705
706 static void
707 update_min_ownertrust (u32 *kid, unsigned int new_trust )
708 {
709   PKT_public_key *pk;
710   TRUSTREC rec;
711   int rc;
712
713   pk = m_alloc_clear (sizeof *pk);
714   rc = get_pubkey (pk, kid);
715   if (rc)
716     {
717       log_error (_("public key %08lX not found: %s\n"),
718                  (ulong)kid[1], g10_errstr(rc) );
719       return;
720     }
721
722   rc = read_trust_record (pk, &rec);
723   if (!rc)
724     {
725       if (DBG_TRUST)
726         log_debug ("key %08lX: update min_ownertrust from %u to %u\n",
727                    (ulong)kid[1],(unsigned int)rec.r.trust.min_ownertrust,
728                    new_trust );
729       if (rec.r.trust.min_ownertrust != new_trust)
730         {
731           rec.r.trust.min_ownertrust = new_trust;
732           write_record( &rec );
733           revalidation_mark ();
734           do_sync ();
735         }
736     }
737   else if (rc == -1)
738     { /* no record yet - create a new one */
739       size_t dummy;
740
741       if (DBG_TRUST)
742         log_debug ("insert min_ownertrust %u\n", new_trust );
743
744       memset (&rec, 0, sizeof rec);
745       rec.recnum = tdbio_new_recnum ();
746       rec.rectype = RECTYPE_TRUST;
747       fingerprint_from_pk (pk, rec.r.trust.fingerprint, &dummy);
748       rec.r.trust.min_ownertrust = new_trust;
749       write_record (&rec);
750       revalidation_mark ();
751       do_sync ();
752       rc = 0;
753     }
754   else 
755     {
756       tdbio_invalid ();
757     }
758 }
759
760 /* Clear the ownertrust and min_ownertrust values.  Return true if a
761    change actually happened. */
762 int
763 clear_ownertrusts (PKT_public_key *pk)
764 {
765   TRUSTREC rec;
766   int rc;
767   
768   rc = read_trust_record (pk, &rec);
769   if (!rc)
770     {
771       if (DBG_TRUST)
772         {
773           log_debug ("clearing ownertrust (old value %u)\n",
774                      (unsigned int)rec.r.trust.ownertrust);
775           log_debug ("clearing min_ownertrust (old value %u)\n",
776                      (unsigned int)rec.r.trust.min_ownertrust);
777         }
778       if (rec.r.trust.ownertrust || rec.r.trust.min_ownertrust)
779         {
780           rec.r.trust.ownertrust = 0;
781           rec.r.trust.min_ownertrust = 0;
782           write_record( &rec );
783           revalidation_mark ();
784           do_sync ();
785           return 1;
786         }
787     }
788   else if (rc != -1)
789     {
790       tdbio_invalid ();
791     }
792   return 0;
793 }
794
795 /* 
796  * Note: Caller has to do a sync 
797  */
798 static void
799 update_validity (PKT_public_key *pk, const byte *namehash,
800                  int depth, int validity)
801 {
802   TRUSTREC trec, vrec;
803   int rc;
804   ulong recno;
805   
806   rc = read_trust_record (pk, &trec);
807   if (rc && rc != -1)
808     {
809       tdbio_invalid ();
810       return;
811     }
812   if (rc == -1) /* no record yet - create a new one */
813     { 
814       size_t dummy;
815
816       rc = 0;
817       memset (&trec, 0, sizeof trec);
818       trec.recnum = tdbio_new_recnum ();
819       trec.rectype = RECTYPE_TRUST;
820       fingerprint_from_pk (pk, trec.r.trust.fingerprint, &dummy);
821       trec.r.trust.ownertrust = 0;
822       }
823
824   /* locate an existing one */
825   recno = trec.r.trust.validlist;
826   while (recno)
827     {
828       read_record (recno, &vrec, RECTYPE_VALID);
829       if ( !memcmp (vrec.r.valid.namehash, namehash, 20) )
830         break;
831       recno = vrec.r.valid.next;
832     }
833
834   if (!recno) /* insert a new validity record */
835     {
836       memset (&vrec, 0, sizeof vrec);
837       vrec.recnum = tdbio_new_recnum ();
838       vrec.rectype = RECTYPE_VALID;
839       memcpy (vrec.r.valid.namehash, namehash, 20);
840       vrec.r.valid.next = trec.r.trust.validlist;
841     }
842   vrec.r.valid.validity = validity;
843   write_record (&vrec);
844   trec.r.trust.depth = depth;
845   trec.r.trust.validlist = vrec.recnum;
846   write_record (&trec);
847 }
848
849
850 /* reset validity for all user IDs.  Caller must sync. */
851 static int
852 clear_validity (PKT_public_key *pk)
853 {
854   TRUSTREC trec, vrec;
855   int rc;
856   ulong recno;
857   int any = 0;
858   
859   rc = read_trust_record (pk, &trec);
860   if (rc && rc != -1)
861     {
862       tdbio_invalid ();
863       return 0;
864     }
865   if (rc == -1) /* no record yet - no need to clear it then ;-) */
866     return 0;
867
868   /* Clear minimum ownertrust, if any */
869   if(trec.r.trust.min_ownertrust)
870     {
871       trec.r.trust.min_ownertrust=0;
872       write_record(&trec);
873     }
874
875   /* reset validity for all user IDs */
876   recno = trec.r.trust.validlist;
877   while (recno)
878     {
879       read_record (recno, &vrec, RECTYPE_VALID);
880       if ((vrec.r.valid.validity & TRUST_MASK))
881         {
882           vrec.r.valid.validity &= ~TRUST_MASK;
883           write_record (&vrec);
884           any = 1;
885         }
886       recno = vrec.r.valid.next;
887     }
888
889   return any;
890 }
891
892 /***********************************************
893  *********  Query trustdb values  **************
894  ***********************************************/
895
896 /*
897  * Return the validity information for PK.  If the namehash is not
898  * NULL, the validity of the corresponsing user ID is returned,
899  * otherwise, a reasonable value for the entire key is returned. 
900  */
901 unsigned int
902 get_validity (PKT_public_key *pk, const byte *namehash)
903 {
904   static int did_nextcheck;
905   TRUSTREC trec, vrec;
906   int rc;
907   ulong recno;
908   unsigned int validity;
909   u32 kid[2];
910   PKT_public_key *main_pk;
911
912   init_trustdb ();
913   if (!did_nextcheck)
914     {
915       ulong scheduled;
916
917       did_nextcheck = 1;
918       scheduled = tdbio_read_nextcheck ();
919       if (scheduled && scheduled <= make_timestamp ())
920         {
921           if (opt.no_auto_check_trustdb) 
922             {
923               pending_check_trustdb = 1;
924               log_info ("please do a --check-trustdb\n");
925             }
926           else
927             {
928               log_info (_("checking the trustdb\n"));
929               validate_keys (0);
930             }
931         }
932     }
933
934   keyid_from_pk (pk, kid);
935   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
936     { /* this is a subkey - get the mainkey */
937       main_pk = m_alloc_clear (sizeof *main_pk);
938       rc = get_pubkey (main_pk, pk->main_keyid);
939       if (rc)
940         {
941           log_error ("error getting main key %08lX of subkey %08lX: %s\n",
942                      (ulong)pk->main_keyid[1], (ulong)kid[1], g10_errstr(rc));
943           validity = TRUST_UNKNOWN; 
944           goto leave;
945         }
946     }
947   else
948     main_pk = pk;
949
950   rc = read_trust_record (main_pk, &trec);
951   if (rc && rc != -1)
952     {
953       tdbio_invalid ();
954       return 0;
955     }
956   if (rc == -1) /* no record found */
957     {
958       validity = TRUST_UNKNOWN; 
959       goto leave;
960     }
961
962   /* loop over all user IDs */
963   recno = trec.r.trust.validlist;
964   validity = 0;
965   while (recno)
966     {
967       read_record (recno, &vrec, RECTYPE_VALID);
968       if ( validity < (vrec.r.valid.validity & TRUST_MASK) )
969         validity = (vrec.r.valid.validity & TRUST_MASK);
970       if ( namehash && !memcmp (vrec.r.valid.namehash, namehash, 20) )
971         break;
972       recno = vrec.r.valid.next;
973     }
974   
975   if (recno) /* okay, use the user ID associated one */
976     validity = (vrec.r.valid.validity & TRUST_MASK);
977
978   if ( (trec.r.trust.ownertrust & TRUST_FLAG_DISABLED) )
979     validity |= TRUST_FLAG_DISABLED;
980
981  leave:
982   /* set some flags direct from the key */
983   if (main_pk->is_revoked)
984     validity |= TRUST_FLAG_REVOKED;
985   if (main_pk != pk && pk->is_revoked)
986     validity |= TRUST_FLAG_SUB_REVOKED;
987   /* Note: expiration is a trust value and not a flag - don't know why
988    * I initially designed it that way */
989   if (main_pk->has_expired || pk->has_expired)
990     validity = (validity & ~TRUST_MASK) | TRUST_EXPIRED;
991   
992   if (pending_check_trustdb)
993     validity |= TRUST_FLAG_PENDING_CHECK;
994
995   if (main_pk != pk)
996     free_public_key (main_pk);
997   return validity;
998 }
999
1000
1001 int
1002 get_validity_info (PKT_public_key *pk, const byte *namehash)
1003 {
1004     int trustlevel;
1005     int c;
1006
1007     trustlevel = get_validity (pk, namehash);
1008     if( trustlevel & TRUST_FLAG_DISABLED )
1009         return 'd';
1010     if( trustlevel & TRUST_FLAG_REVOKED )
1011         return 'r';
1012     c = trust_letter ( (trustlevel & TRUST_MASK) );
1013     if( !c )
1014         c = '?';
1015     return c;
1016 }
1017
1018
1019
1020
1021 void
1022 list_trust_path( const char *username )
1023 {
1024 }
1025
1026
1027
1028
1029 /****************
1030  * Enumerate all keys, which are needed to build all trust paths for
1031  * the given key.  This function does not return the key itself or
1032  * the ultimate key (the last point in cerificate chain).  Only
1033  * certificate chains which ends up at an ultimately trusted key
1034  * are listed.  If ownertrust or validity is not NULL, the corresponding
1035  * value for the returned LID is also returned in these variable(s).
1036  *
1037  *  1) create a void pointer and initialize it to NULL
1038  *  2) pass this void pointer by reference to this function.
1039  *     Set lid to the key you want to enumerate and pass it by reference.
1040  *  3) call this function as long as it does not return -1
1041  *     to indicate EOF. LID does contain the next key used to build the web
1042  *  4) Always call this function a last time with LID set to NULL,
1043  *     so that it can free its context.
1044  *
1045  * Returns: -1 on EOF or the level of the returned LID
1046  */
1047 int
1048 enum_cert_paths( void **context, ulong *lid,
1049                  unsigned *ownertrust, unsigned *validity )
1050 {
1051     return -1;
1052 }
1053
1054
1055 /****************
1056  * Print the current path
1057  */
1058 void
1059 enum_cert_paths_print( void **context, FILE *fp,
1060                                        int refresh, ulong selected_lid )
1061 {
1062     return;
1063 }
1064
1065
1066 \f
1067 /****************************************
1068  *********** NEW NEW NEW ****************
1069  ****************************************/
1070
1071 static int
1072 ask_ownertrust (u32 *kid,int minimum)
1073 {
1074   PKT_public_key *pk;
1075   int rc;
1076   int ot;
1077
1078   pk = m_alloc_clear (sizeof *pk);
1079   rc = get_pubkey (pk, kid);
1080   if (rc)
1081     {
1082       log_error (_("public key %08lX not found: %s\n"),
1083                  (ulong)kid[1], g10_errstr(rc) );
1084       return TRUST_UNKNOWN;
1085     }
1086  
1087   if(opt.force_ownertrust)
1088     {
1089       log_info("force trust for key %08lX to %s\n",(ulong)kid[1],
1090                trust_string(opt.force_ownertrust));
1091       update_ownertrust(pk,opt.force_ownertrust);
1092       ot=opt.force_ownertrust;
1093     }
1094   else
1095     {
1096       ot=edit_ownertrust(pk,0);
1097       if(ot>0)
1098         ot = get_ownertrust (pk);
1099       else if(ot==0)
1100         ot = minimum?minimum:TRUST_UNDEFINED;
1101       else
1102         ot = -1; /* quit */
1103     }
1104
1105   free_public_key( pk );
1106
1107   return ot;
1108 }
1109
1110
1111 static void
1112 mark_keyblock_seen (KeyHashTable tbl, KBNODE node)
1113 {
1114   for ( ;node; node = node->next )
1115     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1116         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1117       {
1118         u32 aki[2];
1119
1120         keyid_from_pk (node->pkt->pkt.public_key, aki);
1121         add_key_hash_table (tbl, aki);
1122       }
1123 }
1124
1125
1126
1127 static void
1128 dump_key_array (int depth, struct key_array *keys)
1129 {
1130   struct key_array *kar;
1131
1132   for (kar=keys; kar->keyblock; kar++)
1133     {
1134       KBNODE node = kar->keyblock;
1135       u32 kid[2];
1136
1137       keyid_from_pk(node->pkt->pkt.public_key, kid);
1138       printf ("%d:%08lX%08lX:K::%c::::\n",
1139               depth, (ulong)kid[0], (ulong)kid[1], '?');
1140
1141       for (; node; node = node->next)
1142         {
1143           if (node->pkt->pkttype == PKT_USER_ID)
1144             {
1145               int len = node->pkt->pkt.user_id->len;
1146
1147               if (len > 30)
1148                 len = 30;
1149               printf ("%d:%08lX%08lX:U:::%c:::",
1150                       depth, (ulong)kid[0], (ulong)kid[1],
1151                       (node->flag & 4)? 'f':
1152                       (node->flag & 2)? 'm':
1153                       (node->flag & 1)? 'q':'-');
1154               print_string (stdout,  node->pkt->pkt.user_id->name, len, ':');
1155               putchar (':');
1156               putchar ('\n');
1157             }
1158         }
1159     }
1160 }  
1161
1162
1163 static void
1164 store_validation_status (int depth, KBNODE keyblock)
1165 {
1166   KBNODE node;
1167   byte namehash[20];
1168   int status;
1169   int any = 0;
1170
1171   for (node=keyblock; node; node = node->next)
1172     {
1173       if (node->pkt->pkttype == PKT_USER_ID)
1174         {
1175           PKT_user_id *uid = node->pkt->pkt.user_id;
1176
1177           if (node->flag & 4)
1178             status = TRUST_FULLY;
1179           else if (node->flag & 2)
1180             status = TRUST_MARGINAL;
1181           else if (node->flag & 1)
1182             status = TRUST_UNDEFINED;
1183           else
1184             status = 0;
1185           
1186           if (status)
1187             {
1188               if( uid->attrib_data )
1189                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1190               else
1191                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1192               
1193               update_validity (keyblock->pkt->pkt.public_key,
1194                                namehash, depth, status);
1195               any = 1;
1196             }
1197         }
1198     }
1199
1200   if (any)
1201     do_sync ();
1202 }  
1203
1204 /*
1205  * check whether the signature sig is in the klist k
1206  */
1207 static struct key_item *
1208 is_in_klist (struct key_item *k, PKT_signature *sig)
1209 {
1210   for (; k; k = k->next)
1211     {
1212       if (k->kid[0] == sig->keyid[0] && k->kid[1] == sig->keyid[1])
1213         return k;
1214     }
1215   return NULL;
1216 }
1217
1218 /*
1219  * Mark the signature of the given UID which are used to certify it.
1220  * To do this, we first revmove all signatures which are not valid and
1221  * from the remain ones we look for the latest one.  If this is not a
1222  * certification revocation signature we mark the signature by setting
1223  * node flag bit 8.  Note that flag bits 9 and 10 are used for internal
1224  * purposes.  
1225  */
1226 static void
1227 mark_usable_uid_certs (KBNODE keyblock, KBNODE uidnode,
1228                        u32 *main_kid, struct key_item *klist,
1229                        u32 curtime, u32 *next_expire)
1230 {
1231   KBNODE node;
1232   PKT_signature *sig;
1233   
1234   /* first check all signatures */
1235   for (node=uidnode->next; node; node = node->next)
1236     {
1237       node->flag &= ~(1<<8 | 1<<9 | 1<<10);
1238       if (node->pkt->pkttype == PKT_USER_ID
1239           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1240         break; /* ready */
1241       if (node->pkt->pkttype != PKT_SIGNATURE)
1242         continue;
1243       
1244       sig = node->pkt->pkt.signature;
1245       if (sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
1246         continue; /* ignore self-signatures */
1247       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
1248         continue; /* we only look at these signature classes */
1249       if (!is_in_klist (klist, sig))
1250         continue;  /* no need to check it then */
1251       if (check_key_signature (keyblock, node, NULL))
1252         continue; /* ignore invalid signatures */
1253       node->flag |= 1<<9;
1254     }      
1255   /* reset the remaining flags */
1256   for (; node; node = node->next)
1257       node->flag &= ~(1<<8 | 1<<9 | 1 << 10);
1258
1259   /* kbnode flag usage: bit 9 is here set for signatures to consider,
1260    * bit 10 will be set by the loop to keep track of keyIDs already
1261    * processed, bit 8 will be set for the usable signatures */
1262
1263   /* for each cert figure out the latest valid one */
1264   for (node=uidnode->next; node; node = node->next)
1265     {
1266       KBNODE n, signode;
1267       u32 kid[2];
1268       u32 sigdate;
1269       
1270       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1271         break;
1272       if ( !(node->flag & (1<<9)) )
1273         continue; /* not a node to look at */
1274       if ( (node->flag & (1<<10)) )
1275         continue; /* signature with a keyID already processed */
1276       node->flag |= (1<<10); /* mark this node as processed */
1277       sig = node->pkt->pkt.signature;
1278       signode = node;
1279       sigdate = sig->timestamp;
1280       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
1281       for (n=uidnode->next; n; n = n->next)
1282         {
1283           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1284             break;
1285           if ( !(n->flag & (1<<9)) )
1286             continue;
1287           if ( (n->flag & (1<<10)) )
1288             continue; /* shortcut already processed signatures */
1289           sig = n->pkt->pkt.signature;
1290           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
1291             continue;
1292           n->flag |= (1<<10); /* mark this node as processed */
1293
1294           /* If signode is nonrevocable and unexpired and n isn't,
1295              then take signode (skip).  It doesn't matter which is
1296              older: if signode was older then we don't want to take n
1297              as signode is nonrevocable.  If n was older then we're
1298              automatically fine. */
1299           
1300           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
1301                !signode->pkt->pkt.signature->flags.revocable &&
1302                (signode->pkt->pkt.signature->expiredate==0 ||
1303                 signode->pkt->pkt.signature->expiredate>curtime))) &&
1304              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
1305                 !n->pkt->pkt.signature->flags.revocable &&
1306                 (n->pkt->pkt.signature->expiredate==0 ||
1307                  n->pkt->pkt.signature->expiredate>curtime))))
1308             continue;
1309
1310           /* If n is nonrevocable and unexpired and signode isn't,
1311              then take n.  Again, it doesn't matter which is older: if
1312              n was older then we don't want to take signode as n is
1313              nonrevocable.  If signode was older then we're
1314              automatically fine. */
1315           
1316           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
1317                 !signode->pkt->pkt.signature->flags.revocable &&
1318                 (signode->pkt->pkt.signature->expiredate==0 ||
1319                  signode->pkt->pkt.signature->expiredate>curtime))) &&
1320              ((IS_UID_SIG(n->pkt->pkt.signature) &&
1321                !n->pkt->pkt.signature->flags.revocable &&
1322                (n->pkt->pkt.signature->expiredate==0 ||
1323                 n->pkt->pkt.signature->expiredate>curtime))))
1324             {
1325               signode = n;
1326               sigdate = sig->timestamp;
1327               continue;
1328             }
1329
1330           /* At this point, if it's newer, it goes in as the only
1331              remaining possibilities are signode and n are both either
1332              revocable or expired or both nonrevocable and unexpired.
1333              If the timestamps are equal take the later ordered
1334              packet, presuming that the key packets are hopefully in
1335              their original order. */
1336
1337           if (sig->timestamp >= sigdate)
1338             {
1339               signode = n;
1340               sigdate = sig->timestamp;
1341             }
1342         }
1343       sig = signode->pkt->pkt.signature;
1344       if (IS_UID_SIG (sig))
1345         { /* this seems to be a usable one which is not revoked. 
1346            * Just need to check whether there is an expiration time,
1347            * We do the expired certification after finding a suitable
1348            * certification, the assumption is that a signator does not
1349            * want that after the expiration of his certificate the
1350            * system falls back to an older certification which has a
1351            * different expiration time */
1352           const byte *p;
1353           u32 expire;
1354                     
1355           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
1356           expire = p? sig->timestamp + buffer_to_u32(p) : 0;
1357
1358           if (expire==0 || expire > curtime )
1359             {
1360               signode->flag |= (1<<8); /* yeah, found a good cert */
1361               if (expire && expire < *next_expire)
1362                 *next_expire = expire;
1363             }
1364         }
1365     }
1366 }
1367
1368 /* Used by validate_one_keyblock to confirm a regexp within a trust
1369    signature.  Returns 1 for match, and 0 for no match or regex
1370    error. */
1371 static int
1372 check_regexp(const char *exp,const char *string)
1373 {
1374 #ifdef DISABLE_REGEXP
1375   /* When DISABLE_REGEXP is defined, assume all regexps do not
1376      match. */
1377   return 0;
1378 #elif defined(__riscos__)
1379   return riscos_check_regexp(exp, string, DBG_TRUST);
1380 #else
1381   int ret;
1382   regex_t pat;
1383
1384   if(regcomp(&pat,exp,REG_ICASE|REG_NOSUB|REG_EXTENDED)!=0)
1385     return 0;
1386
1387   ret=regexec(&pat,string,0,NULL,0);
1388
1389   regfree(&pat);
1390
1391   if(DBG_TRUST)
1392     log_debug("regexp \"%s\" on \"%s\": %s\n",exp,string,ret==0?"YES":"NO");
1393
1394   return (ret==0);
1395 #endif
1396 }
1397
1398 /*
1399  * Return true if the key is signed by one of the keys in the given
1400  * key ID list.  User IDs with a valid signature are marked by node
1401  * flags as follows:
1402  *  flag bit 0: There is at least one signature
1403  *           1: There is marginal confidence that this is a legitimate uid
1404  *           2: There is full confidence that this is a legitimate uid.
1405  *           8: Used for internal purposes.
1406  *           9: Ditto (in mark_usable_uid_certs())
1407  *          10: Ditto (ditto)
1408  * This function assumes that all kbnode flags are cleared on entry.
1409  */
1410 static int
1411 validate_one_keyblock (KBNODE kb, struct key_item *klist,
1412                        u32 curtime, u32 *next_expire)
1413 {
1414   struct key_item *kr;
1415   KBNODE node, uidnode=NULL;
1416   PKT_public_key *pk = kb->pkt->pkt.public_key;
1417   u32 main_kid[2];
1418   int issigned=0, any_signed = 0, fully_count =0, marginal_count = 0;
1419
1420   keyid_from_pk(pk, main_kid);
1421   for (node=kb; node; node = node->next)
1422     {
1423       if (node->pkt->pkttype == PKT_USER_ID)
1424         {
1425           if (uidnode && issigned)
1426             {
1427               if (fully_count >= opt.completes_needed
1428                   || marginal_count >= opt.marginals_needed )
1429                 uidnode->flag |= 4; 
1430               else if (fully_count || marginal_count)
1431                 uidnode->flag |= 2;
1432               uidnode->flag |= 1;
1433               any_signed = 1;
1434             }
1435           uidnode = node;
1436           issigned = 0;
1437           fully_count = marginal_count = 0;
1438           mark_usable_uid_certs (kb, uidnode, main_kid, klist, 
1439                                  curtime, next_expire);
1440         }
1441       else if (node->pkt->pkttype == PKT_SIGNATURE 
1442                && (node->flag & (1<<8)) )
1443         {
1444           /* Note that we are only seeing unrevoked sigs here */
1445           PKT_signature *sig = node->pkt->pkt.signature;
1446           
1447           kr = is_in_klist (klist, sig);
1448           /* If the trust_regexp does not match, it's as if the sig
1449              did not exist.  This is safe for non-trust sigs as well
1450              since we don't accept a regexp on the sig unless it's a
1451              trust sig. */
1452           if (kr && (kr->trust_regexp==NULL || opt.trust_model!=TM_OPENPGP ||
1453                      (uidnode && check_regexp(kr->trust_regexp,
1454                                             uidnode->pkt->pkt.user_id->name))))
1455             {
1456               if(DBG_TRUST && opt.trust_model==TM_OPENPGP && sig->trust_depth)
1457                 log_debug("trust sig on %s, sig depth is %d, kr depth is %d\n",
1458                           uidnode->pkt->pkt.user_id->name,sig->trust_depth,
1459                           kr->trust_depth);
1460
1461               /* Are we part of a trust sig chain?  We always favor
1462                  the latest trust sig, rather than the greater or
1463                  lesser trust sig or value.  I could make a decent
1464                  argument for any of these cases, but this seems to be
1465                  what PGP does, and I'd like to be compatible. -dms */
1466               if(opt.trust_model==TM_OPENPGP && sig->trust_depth
1467                  && pk->trust_timestamp<=sig->timestamp
1468                  && (sig->trust_depth<=kr->trust_depth
1469                      || kr->ownertrust==TRUST_ULTIMATE))
1470                 {
1471                   /* If we got here, we know that:
1472
1473                      this is a trust sig.
1474
1475                      it's a newer trust sig than any previous trust
1476                      sig on this key (not uid).
1477
1478                      it is legal in that it was either generated by an
1479                      ultimate key, or a key that was part of a trust
1480                      chain, and the depth does not violate the
1481                      original trust sig.
1482
1483                      if there is a regexp attached, it matched
1484                      successfully.
1485                   */
1486
1487                   if(DBG_TRUST)
1488                     log_debug("replacing trust value %d with %d and "
1489                               "depth %d with %d\n",
1490                               pk->trust_value,sig->trust_value,
1491                               pk->trust_depth,sig->trust_depth);
1492
1493                   pk->trust_value=sig->trust_value;
1494                   pk->trust_depth=sig->trust_depth-1;
1495
1496                   /* If the trust sig contains a regexp, record it
1497                      on the pk for the next round. */
1498                   if(sig->trust_regexp)
1499                     pk->trust_regexp=sig->trust_regexp;
1500                 }
1501
1502               if (kr->ownertrust == TRUST_ULTIMATE)
1503                 fully_count = opt.completes_needed;
1504               else if (kr->ownertrust == TRUST_FULLY)
1505                 fully_count++;
1506               else if (kr->ownertrust == TRUST_MARGINAL)
1507                 marginal_count++;
1508               issigned = 1;
1509             }
1510         }
1511     }
1512
1513   if (uidnode && issigned)
1514     {
1515       if (fully_count >= opt.completes_needed
1516                || marginal_count >= opt.marginals_needed )
1517         uidnode->flag |= 4; 
1518       else if (fully_count || marginal_count)
1519         uidnode->flag |= 2;
1520       uidnode->flag |= 1;
1521       any_signed = 1;
1522     }
1523
1524   return any_signed;
1525 }
1526
1527
1528 static int
1529 search_skipfnc (void *opaque, u32 *kid)
1530 {
1531   return test_key_hash_table ((KeyHashTable)opaque, kid);
1532 }
1533
1534
1535 /*
1536  * Scan all keys and return a key_array of all suitable keys from
1537  * kllist.  The caller has to pass keydb handle so that we don't use
1538  * to create our own.  Returns either a key_array or NULL in case of
1539  * an error.  No results found are indicated by an empty array.
1540  * Caller hast to release the returned array.  
1541  */
1542 static struct key_array *
1543 validate_key_list (KEYDB_HANDLE hd, KeyHashTable visited,
1544                    struct key_item *klist, u32 curtime, u32 *next_expire)
1545 {
1546   KBNODE keyblock = NULL;
1547   struct key_array *keys = NULL;
1548   size_t nkeys, maxkeys;
1549   int rc;
1550   KEYDB_SEARCH_DESC desc;
1551   
1552   maxkeys = 1000;
1553   keys = m_alloc ((maxkeys+1) * sizeof *keys);
1554   nkeys = 0;
1555   
1556   rc = keydb_search_reset (hd);
1557   if (rc)
1558     {
1559       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1560       m_free (keys);
1561       return NULL;
1562     }
1563
1564   memset (&desc, 0, sizeof desc);
1565   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1566   desc.skipfnc = search_skipfnc;
1567   desc.skipfncvalue = visited;
1568   rc = keydb_search (hd, &desc, 1);
1569   if (rc == -1)
1570     {
1571       keys[nkeys].keyblock = NULL;
1572       return keys;
1573     }
1574   if (rc)
1575     {
1576       log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1577       m_free (keys);
1578       return NULL;
1579     }
1580   
1581   desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1582   do
1583     {
1584       PKT_public_key *pk;
1585         
1586       rc = keydb_get_keyblock (hd, &keyblock);
1587       if (rc) 
1588         {
1589           log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1590           m_free (keys);
1591           return NULL;
1592         }
1593       
1594       if ( keyblock->pkt->pkttype != PKT_PUBLIC_KEY) 
1595         {
1596           log_debug ("ooops: invalid pkttype %d encountered\n",
1597                      keyblock->pkt->pkttype);
1598           dump_kbnode (keyblock);
1599           release_kbnode(keyblock);
1600           continue;
1601         }
1602
1603       /* prepare the keyblock for further processing */
1604       merge_keys_and_selfsig (keyblock); 
1605       clear_kbnode_flags (keyblock);
1606       pk = keyblock->pkt->pkt.public_key;
1607       if (pk->has_expired || pk->is_revoked)
1608         {
1609           /* it does not make sense to look further at those keys */
1610           mark_keyblock_seen (visited, keyblock);
1611         }
1612       else if (validate_one_keyblock (keyblock, klist, curtime, next_expire))
1613         {
1614           if (pk->expiredate && pk->expiredate >= curtime
1615               && pk->expiredate < *next_expire)
1616             *next_expire = pk->expiredate;
1617
1618           if (nkeys == maxkeys) {
1619             maxkeys += 1000;
1620             keys = m_realloc (keys, (maxkeys+1) * sizeof *keys);
1621           }
1622           keys[nkeys++].keyblock = keyblock;
1623           /* this key is signed - don't check it again */
1624           mark_keyblock_seen (visited, keyblock);
1625           keyblock = NULL;
1626         }
1627
1628       release_kbnode (keyblock);
1629       keyblock = NULL;
1630     } 
1631   while ( !(rc = keydb_search (hd, &desc, 1)) );
1632   if (rc && rc != -1) 
1633     {
1634       log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1635       m_free (keys);
1636       return NULL;
1637     }
1638
1639   keys[nkeys].keyblock = NULL;
1640   return keys;
1641
1642
1643
1644 static void
1645 reset_unconnected_keys (KEYDB_HANDLE hd, KeyHashTable visited)
1646 {
1647   int rc;
1648   KBNODE keyblock = NULL;
1649   KEYDB_SEARCH_DESC desc;
1650   int count = 0, nreset = 0;
1651   
1652   rc = keydb_search_reset (hd);
1653   if (rc)
1654     {
1655       log_error ("keydb_search_reset failed: %s\n", g10_errstr(rc));
1656       return;
1657     }
1658
1659   memset (&desc, 0, sizeof desc);
1660   desc.mode = KEYDB_SEARCH_MODE_FIRST;
1661   desc.skipfnc = search_skipfnc;
1662   desc.skipfncvalue = visited;
1663   rc = keydb_search (hd, &desc, 1);
1664   if (rc && rc != -1 )
1665     log_error ("keydb_search_first failed: %s\n", g10_errstr(rc));
1666   else if (!rc)
1667     {
1668       desc.mode = KEYDB_SEARCH_MODE_NEXT; /* change mode */
1669       do
1670         {
1671           rc = keydb_get_keyblock (hd, &keyblock);
1672           if (rc) 
1673             {
1674               log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
1675               break;
1676             }
1677           count++;
1678
1679           if (keyblock->pkt->pkttype == PKT_PUBLIC_KEY) /* paranoid assertion*/
1680             {
1681               nreset += clear_validity (keyblock->pkt->pkt.public_key);
1682               release_kbnode (keyblock);
1683             } 
1684         }
1685       while ( !(rc = keydb_search (hd, &desc, 1)) );
1686       if (rc && rc != -1) 
1687         log_error ("keydb_search_next failed: %s\n", g10_errstr(rc));
1688     }
1689   if (opt.verbose)
1690     log_info ("%d unconnected keys (%d trust records cleared)\n",
1691               count, nreset);
1692   do_sync ();
1693
1694
1695
1696 /*
1697  * Run the key validation procedure.
1698  *
1699  * This works this way:
1700  * Step 1: Find all ultimately trusted keys (UTK).
1701  *         mark them all as seen and put them into klist.
1702  * Step 2: loop max_cert_times
1703  * Step 3:   if OWNERTRUST of any key in klist is undefined
1704  *             ask user to assign ownertrust
1705  * Step 4:   Loop over all keys in the keyDB which are not marked seen 
1706  * Step 5:     if key is revoked or expired
1707  *                mark key as seen
1708  *                continue loop at Step 4
1709  * Step 6:     For each user ID of that key signed by a key in klist
1710  *                Calculate validity by counting trusted signatures.
1711  *                Set validity of user ID
1712  * Step 7:     If any signed user ID was found
1713  *                mark key as seen
1714  *             End Loop
1715  * Step 8:   Build a new klist from all fully trusted keys from step 6
1716  *           End Loop
1717  *         Ready  
1718  *
1719  */
1720 static int
1721 validate_keys (int interactive)
1722 {
1723   int rc = 0;
1724   int quit=0;
1725   struct key_item *klist = NULL;
1726   struct key_item *k;
1727   struct key_array *keys = NULL;
1728   struct key_array *kar;
1729   KEYDB_HANDLE kdb = NULL;
1730   KBNODE node;
1731   int depth;
1732   int key_count;
1733   int ot_unknown, ot_undefined, ot_never, ot_marginal, ot_full, ot_ultimate;
1734   KeyHashTable visited;
1735   u32 start_time, next_expire;
1736
1737   start_time = make_timestamp ();
1738   next_expire = 0xffffffff; /* set next expire to the year 2106 */
1739   visited = new_key_hash_table ();
1740   /* Fixme: Instead of always building a UTK list, we could just build it
1741    * here when needed */
1742   if (!utk_list)
1743     {
1744       log_info ("no ultimately trusted keys found\n");
1745       goto leave;
1746     }
1747
1748   /* mark all UTKs as visited and set validity to ultimate */
1749   for (k=utk_list; k; k = k->next)
1750     {
1751       KBNODE keyblock;
1752       PKT_public_key *pk;
1753
1754       keyblock = get_pubkeyblock (k->kid);
1755       if (!keyblock)
1756         {
1757           log_error (_("public key of ultimately"
1758                        " trusted key %08lX not found\n"), (ulong)k->kid[1]);
1759           continue;
1760         }
1761       mark_keyblock_seen (visited, keyblock);
1762       pk = keyblock->pkt->pkt.public_key;
1763       for (node=keyblock; node; node = node->next)
1764         {
1765           if (node->pkt->pkttype == PKT_USER_ID)
1766             {
1767               byte namehash[20];
1768               PKT_user_id *uid = node->pkt->pkt.user_id;
1769               
1770               if( uid->attrib_data )
1771                 rmd160_hash_buffer (namehash,uid->attrib_data,uid->attrib_len);
1772               else
1773                 rmd160_hash_buffer (namehash, uid->name, uid->len );
1774               update_validity (pk, namehash, 0, TRUST_ULTIMATE);
1775             }
1776         }
1777       if ( pk->expiredate && pk->expiredate >= start_time
1778            && pk->expiredate < next_expire)
1779         next_expire = pk->expiredate;
1780       
1781       release_kbnode (keyblock);
1782       do_sync ();
1783     }
1784
1785   klist = utk_list;
1786   kdb = keydb_new (0);
1787
1788   log_info(_("%d marginal(s) needed, %d complete(s) needed, %s trust model\n"),
1789            opt.marginals_needed,opt.completes_needed,
1790            opt.trust_model==TM_CLASSIC?"Classic":
1791                           opt.trust_model==TM_OPENPGP?"OpenPGP":"unknown");
1792
1793   for (depth=0; depth < opt.max_cert_depth; depth++)
1794     {
1795       /* See whether we should assign ownertrust values to the keys in
1796          utk_list.  */
1797       ot_unknown = ot_undefined = ot_never = 0;
1798       ot_marginal = ot_full = ot_ultimate = 0;
1799       for (k=klist; k; k = k->next)
1800         {
1801           int min=0;
1802
1803           /* 120 and 60 are as per RFC2440 */
1804           if(k->trust_value>=120)
1805             min=TRUST_FULLY;
1806           else if(k->trust_value>=60)
1807             min=TRUST_MARGINAL;
1808
1809           if(min!=k->min_ownertrust)
1810             update_min_ownertrust(k->kid,min);
1811
1812           if (interactive && k->ownertrust == TRUST_UNKNOWN)
1813             {
1814               k->ownertrust = ask_ownertrust (k->kid,min);
1815
1816               if (k->ownertrust == -1)
1817                 {
1818                   quit=1;
1819                   goto leave;
1820                 }
1821             }
1822
1823           /* This can happen during transition from an old trustdb
1824              before trust sigs.  It can also happen if a user uses two
1825              different versions of GnuPG or changes the --trust-model
1826              setting. */
1827           if(k->ownertrust<min)
1828             {
1829               if(DBG_TRUST)
1830                 log_debug("key %08lX: "
1831                           "overriding ownertrust \"%s\" with \"%s\"\n",
1832                           (ulong)k->kid[1],
1833                           trust_string(k->ownertrust),trust_string(min));
1834
1835               k->ownertrust=min;
1836             }
1837
1838           if (k->ownertrust == TRUST_UNKNOWN)
1839             ot_unknown++;
1840           else if (k->ownertrust == TRUST_UNDEFINED)
1841             ot_undefined++;
1842           else if (k->ownertrust == TRUST_NEVER)
1843             ot_never++;
1844           else if (k->ownertrust == TRUST_MARGINAL)
1845             ot_marginal++;
1846           else if (k->ownertrust == TRUST_FULLY)
1847             ot_full++;
1848           else if (k->ownertrust == TRUST_ULTIMATE)
1849             ot_ultimate++;
1850         }
1851
1852       /* Find all keys which are signed by a key in kdlist */
1853       keys = validate_key_list (kdb, visited, klist, start_time, &next_expire);
1854       if (!keys) 
1855         {
1856           log_error ("validate_key_list failed\n");
1857           rc = G10ERR_GENERAL;
1858           goto leave;
1859         }
1860
1861       for (key_count=0, kar=keys; kar->keyblock; kar++, key_count++)
1862         ;
1863
1864       /* Store the calculated valididation status somewhere */
1865       if (opt.verbose > 1)
1866         dump_key_array (depth, keys);
1867
1868       log_info (_("checking at depth %d signed=%d"
1869                   " ot(-/q/n/m/f/u)=%d/%d/%d/%d/%d/%d\n"), 
1870                 depth, key_count, ot_unknown, ot_undefined,
1871                 ot_never, ot_marginal, ot_full, ot_ultimate ); 
1872
1873       for (kar=keys; kar->keyblock; kar++)
1874           store_validation_status (depth, kar->keyblock);
1875
1876       /* Build a new kdlist from all fully valid keys in KEYS */
1877       if (klist != utk_list)
1878         release_key_items (klist);
1879       klist = NULL;
1880       for (kar=keys; kar->keyblock; kar++)
1881         {
1882           for (node=kar->keyblock; node; node = node->next)
1883             {
1884               if (node->pkt->pkttype == PKT_USER_ID && (node->flag & 4))
1885                 {
1886                   k = new_key_item ();
1887                   keyid_from_pk (kar->keyblock->pkt->pkt.public_key, k->kid);
1888                   k->ownertrust = get_ownertrust (kar->keyblock
1889                                                   ->pkt->pkt.public_key);
1890                   k->min_ownertrust = get_min_ownertrust (kar->keyblock
1891                                                         ->pkt->pkt.public_key);
1892                   k->trust_depth=
1893                     kar->keyblock->pkt->pkt.public_key->trust_depth;
1894                   k->trust_value=
1895                     kar->keyblock->pkt->pkt.public_key->trust_value;
1896                   if(kar->keyblock->pkt->pkt.public_key->trust_regexp)
1897                     k->trust_regexp=
1898                       m_strdup(kar->keyblock->pkt->
1899                                pkt.public_key->trust_regexp);
1900                   k->next = klist;
1901                   klist = k;
1902                   break;
1903                 }
1904             }
1905         }
1906       release_key_array (keys);
1907       keys = NULL;
1908       if (!klist)
1909         break; /* no need to dive in deeper */
1910     }
1911
1912   reset_unconnected_keys (kdb, visited);
1913
1914  leave:
1915   keydb_release (kdb);
1916   release_key_array (keys);
1917   release_key_items (klist);
1918   release_key_hash_table (visited);
1919   if (!rc && !quit) /* mark trustDB as checked */
1920     {
1921       if (next_expire == 0xffffffff || next_expire < start_time )
1922         tdbio_write_nextcheck (0); 
1923       else
1924         {
1925           tdbio_write_nextcheck (next_expire); 
1926           log_info (_("next trustdb check due at %s\n"),
1927                     strtimestamp (next_expire));
1928         }
1929
1930       if(tdbio_update_version_record()!=0)
1931         {
1932           log_error(_("unable to update trustdb version record: "
1933                       "write failed: %s\n"), g10_errstr(rc));
1934           tdbio_invalid();
1935         }
1936
1937       do_sync ();
1938       pending_check_trustdb = 0;
1939     }
1940   return rc;
1941 }